/*
 * Copyright Codeplay Software Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use these files except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// DO NOT MODIFY BY HAND
// This file was automatically generated by generate_pooling_tests.py.
// Results calculated using Tensorflow v1.12.0.

#include <gtest/gtest.h>

#include "sycldnn/padding_mode.h"

#include "sycldnn/pooling/operators.h"

#include "test/types/cartesian_product.h"
#include "test/types/kernel_data_types.h"
#include "test/types/test_backend_types.h"
#include "test/types/to_gtest_types.h"

#include "test/pooling/pooling_fixture.h"

#include <array>
#include <vector>

using namespace sycldnn;  // NOLINT(google-build-using-namespace)
using DataTypeList = sycldnn::types::KernelDataTypes;
using Backends = sycldnn::types::DefaultBackendTypes;

using SNNTypePairs =
    sycldnn::types::CartesianProduct<DataTypeList, Backends>::type;
using GTestTypePairs = sycldnn::types::ToGTestTypes<SNNTypePairs>::type;

template <typename Pair>
using AvgWindow5Stride1Forward =
    PoolingFixture<typename Pair::FirstType, typename Pair::SecondType,
                   pooling::Average, pooling::Forward>;
TYPED_TEST_SUITE(AvgWindow5Stride1Forward, GTestTypePairs);
TYPED_TEST(AvgWindow5Stride1Forward, SAME1x6x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8.,  8.5,  9.,  10., 10.5, 11., 11., 11.5, 12., 13., 13.5, 14.,
      14., 14.5, 15., 16., 16.5, 17., 20., 20.5, 21., 22., 22.5, 23.,
      23., 23.5, 24., 25., 25.5, 26., 26., 26.5, 27., 28., 28.5, 29.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID1x6x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {15., 16., 21., 22.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME1x6x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15., 16., 16., 17., 17., 18., 19., 20., 20., 21., 21., 22., 21., 22., 22.,
      23., 23., 24., 25., 26., 26., 27., 27., 28., 27., 28., 28., 29., 29., 30.,
      31., 32., 32., 33., 33., 34., 39., 40., 40., 41., 41., 42., 43., 44., 44.,
      45., 45., 46., 45., 46., 46., 47., 47., 48., 49., 50., 50., 51., 51., 52.,
      51., 52., 52., 53., 53., 54., 55., 56., 56., 57., 57., 58.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID1x6x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {29., 30., 31., 32.,
                                         41., 42., 43., 44.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME1x6x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29.,  30.,  31.,  32.,  31.,  32.,  33.,  34.,  33.,  34.,  35.,  36.,
      37.,  38.,  39.,  40.,  39.,  40.,  41.,  42.,  41.,  42.,  43.,  44.,
      41.,  42.,  43.,  44.,  43.,  44.,  45.,  46.,  45.,  46.,  47.,  48.,
      49.,  50.,  51.,  52.,  51.,  52.,  53.,  54.,  53.,  54.,  55.,  56.,
      53.,  54.,  55.,  56.,  55.,  56.,  57.,  58.,  57.,  58.,  59.,  60.,
      61.,  62.,  63.,  64.,  63.,  64.,  65.,  66.,  65.,  66.,  67.,  68.,
      77.,  78.,  79.,  80.,  79.,  80.,  81.,  82.,  81.,  82.,  83.,  84.,
      85.,  86.,  87.,  88.,  87.,  88.,  89.,  90.,  89.,  90.,  91.,  92.,
      89.,  90.,  91.,  92.,  91.,  92.,  93.,  94.,  93.,  94.,  95.,  96.,
      97.,  98.,  99.,  100., 99.,  100., 101., 102., 101., 102., 103., 104.,
      101., 102., 103., 104., 103., 104., 105., 106., 105., 106., 107., 108.,
      109., 110., 111., 112., 111., 112., 113., 114., 113., 114., 115., 116.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID1x6x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {57., 58., 59., 60., 61., 62.,
                                         63., 64., 81., 82., 83., 84.,
                                         85., 86., 87., 88.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME1x6x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9.,   9.5,  10.,  11.,  12.,  12.5, 13.,  12.5, 13.,  13.5, 14.5,
      15.5, 16.,  16.5, 16.,  16.5, 17.,  18.,  19.,  19.5, 20.,  23.,
      23.5, 24.,  25.,  26.,  26.5, 27.,  26.5, 27.,  27.5, 28.5, 29.5,
      30.,  30.5, 30.,  30.5, 31.,  32.,  33.,  33.5, 34.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID1x6x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {17., 18., 19., 24., 25., 26.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME1x6x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17., 18., 18., 19., 19., 20., 21., 22., 23., 24., 24., 25., 25., 26.,
      24., 25., 25., 26., 26., 27., 28., 29., 30., 31., 31., 32., 32., 33.,
      31., 32., 32., 33., 33., 34., 35., 36., 37., 38., 38., 39., 39., 40.,
      45., 46., 46., 47., 47., 48., 49., 50., 51., 52., 52., 53., 53., 54.,
      52., 53., 53., 54., 54., 55., 56., 57., 58., 59., 59., 60., 60., 61.,
      59., 60., 60., 61., 61., 62., 63., 64., 65., 66., 66., 67., 67., 68.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID1x6x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {33., 34., 35., 36., 37., 38.,
                                         47., 48., 49., 50., 51., 52.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME1x6x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      33.,  34.,  35.,  36.,  35.,  36.,  37.,  38.,  37.,  38.,  39.,  40.,
      41.,  42.,  43.,  44.,  45.,  46.,  47.,  48.,  47.,  48.,  49.,  50.,
      49.,  50.,  51.,  52.,  47.,  48.,  49.,  50.,  49.,  50.,  51.,  52.,
      51.,  52.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,  61.,  62.,
      61.,  62.,  63.,  64.,  63.,  64.,  65.,  66.,  61.,  62.,  63.,  64.,
      63.,  64.,  65.,  66.,  65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,
      73.,  74.,  75.,  76.,  75.,  76.,  77.,  78.,  77.,  78.,  79.,  80.,
      89.,  90.,  91.,  92.,  91.,  92.,  93.,  94.,  93.,  94.,  95.,  96.,
      97.,  98.,  99.,  100., 101., 102., 103., 104., 103., 104., 105., 106.,
      105., 106., 107., 108., 103., 104., 105., 106., 105., 106., 107., 108.,
      107., 108., 109., 110., 111., 112., 113., 114., 115., 116., 117., 118.,
      117., 118., 119., 120., 119., 120., 121., 122., 117., 118., 119., 120.,
      119., 120., 121., 122., 121., 122., 123., 124., 125., 126., 127., 128.,
      129., 130., 131., 132., 131., 132., 133., 134., 133., 134., 135., 136.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID1x6x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      65., 66., 67., 68., 69., 70., 71., 72.,  73.,  74.,  75.,  76.,
      93., 94., 95., 96., 97., 98., 99., 100., 101., 102., 103., 104.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME1x6x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10., 10.5, 11.,  12., 13., 14.,  14.5, 15., 14., 14.5, 15.,  16.,
      17., 18.,  18.5, 19., 18., 18.5, 19.,  20., 21., 22.,  22.5, 23.,
      26., 26.5, 27.,  28., 29., 30.,  30.5, 31., 30., 30.5, 31.,  32.,
      33., 34.,  34.5, 35., 34., 34.5, 35.,  36., 37., 38.,  38.5, 39.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID1x6x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {19., 20., 21., 22.,
                                         27., 28., 29., 30.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME1x6x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19., 20., 20., 21., 21., 22., 23., 24., 25., 26., 27., 28., 28., 29.,
      29., 30., 27., 28., 28., 29., 29., 30., 31., 32., 33., 34., 35., 36.,
      36., 37., 37., 38., 35., 36., 36., 37., 37., 38., 39., 40., 41., 42.,
      43., 44., 44., 45., 45., 46., 51., 52., 52., 53., 53., 54., 55., 56.,
      57., 58., 59., 60., 60., 61., 61., 62., 59., 60., 60., 61., 61., 62.,
      63., 64., 65., 66., 67., 68., 68., 69., 69., 70., 67., 68., 68., 69.,
      69., 70., 71., 72., 73., 74., 75., 76., 76., 77., 77., 78.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID1x6x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {37., 38., 39., 40., 41., 42.,
                                         43., 44., 53., 54., 55., 56.,
                                         57., 58., 59., 60.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME1x6x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      37.,  38.,  39.,  40.,  39.,  40.,  41.,  42.,  41.,  42.,  43.,  44.,
      45.,  46.,  47.,  48.,  49.,  50.,  51.,  52.,  53.,  54.,  55.,  56.,
      55.,  56.,  57.,  58.,  57.,  58.,  59.,  60.,  53.,  54.,  55.,  56.,
      55.,  56.,  57.,  58.,  57.,  58.,  59.,  60.,  61.,  62.,  63.,  64.,
      65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,  71.,  72.,  73.,  74.,
      73.,  74.,  75.,  76.,  69.,  70.,  71.,  72.,  71.,  72.,  73.,  74.,
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,
      85.,  86.,  87.,  88.,  87.,  88.,  89.,  90.,  89.,  90.,  91.,  92.,
      101., 102., 103., 104., 103., 104., 105., 106., 105., 106., 107., 108.,
      109., 110., 111., 112., 113., 114., 115., 116., 117., 118., 119., 120.,
      119., 120., 121., 122., 121., 122., 123., 124., 117., 118., 119., 120.,
      119., 120., 121., 122., 121., 122., 123., 124., 125., 126., 127., 128.,
      129., 130., 131., 132., 133., 134., 135., 136., 135., 136., 137., 138.,
      137., 138., 139., 140., 133., 134., 135., 136., 135., 136., 137., 138.,
      137., 138., 139., 140., 141., 142., 143., 144., 145., 146., 147., 148.,
      149., 150., 151., 152., 151., 152., 153., 154., 153., 154., 155., 156.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID1x6x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  81.,  82.,  83.,
      84.,  85.,  86.,  87.,  88.,  105., 106., 107., 108., 109., 110.,
      111., 112., 113., 114., 115., 116., 117., 118., 119., 120.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME1x7x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8.,   8.5,  9.,   10.,  10.5, 11.,  11.,  11.5, 12.,  13.,  13.5,
      14.,  14.,  14.5, 15.,  16.,  16.5, 17.,  20.,  20.5, 21.,  22.,
      22.5, 23.,  26.,  26.5, 27.,  28.,  28.5, 29.,  29.,  29.5, 30.,
      31.,  31.5, 32.,  32.,  32.5, 33.,  34.,  34.5, 35.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID1x7x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {15., 16., 21., 22., 27., 28.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME1x7x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15., 16., 16., 17., 17., 18., 19., 20., 20., 21., 21., 22., 21., 22.,
      22., 23., 23., 24., 25., 26., 26., 27., 27., 28., 27., 28., 28., 29.,
      29., 30., 31., 32., 32., 33., 33., 34., 39., 40., 40., 41., 41., 42.,
      43., 44., 44., 45., 45., 46., 51., 52., 52., 53., 53., 54., 55., 56.,
      56., 57., 57., 58., 57., 58., 58., 59., 59., 60., 61., 62., 62., 63.,
      63., 64., 63., 64., 64., 65., 65., 66., 67., 68., 68., 69., 69., 70.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID1x7x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {29., 30., 31., 32., 41., 42.,
                                         43., 44., 53., 54., 55., 56.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME1x7x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29.,  30.,  31.,  32.,  31.,  32.,  33.,  34.,  33.,  34.,  35.,  36.,
      37.,  38.,  39.,  40.,  39.,  40.,  41.,  42.,  41.,  42.,  43.,  44.,
      41.,  42.,  43.,  44.,  43.,  44.,  45.,  46.,  45.,  46.,  47.,  48.,
      49.,  50.,  51.,  52.,  51.,  52.,  53.,  54.,  53.,  54.,  55.,  56.,
      53.,  54.,  55.,  56.,  55.,  56.,  57.,  58.,  57.,  58.,  59.,  60.,
      61.,  62.,  63.,  64.,  63.,  64.,  65.,  66.,  65.,  66.,  67.,  68.,
      77.,  78.,  79.,  80.,  79.,  80.,  81.,  82.,  81.,  82.,  83.,  84.,
      85.,  86.,  87.,  88.,  87.,  88.,  89.,  90.,  89.,  90.,  91.,  92.,
      101., 102., 103., 104., 103., 104., 105., 106., 105., 106., 107., 108.,
      109., 110., 111., 112., 111., 112., 113., 114., 113., 114., 115., 116.,
      113., 114., 115., 116., 115., 116., 117., 118., 117., 118., 119., 120.,
      121., 122., 123., 124., 123., 124., 125., 126., 125., 126., 127., 128.,
      125., 126., 127., 128., 127., 128., 129., 130., 129., 130., 131., 132.,
      133., 134., 135., 136., 135., 136., 137., 138., 137., 138., 139., 140.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID1x7x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      57., 58., 59., 60., 61.,  62.,  63.,  64.,  81.,  82.,  83.,  84.,
      85., 86., 87., 88., 105., 106., 107., 108., 109., 110., 111., 112.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME1x7x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9.,   9.5,  10.,  11.,  12., 12.5, 13.,  12.5, 13.,  13.5,
      14.5, 15.5, 16.,  16.5, 16., 16.5, 17.,  18.,  19.,  19.5,
      20.,  23.,  23.5, 24.,  25., 26.,  26.5, 27.,  30.,  30.5,
      31.,  32.,  33.,  33.5, 34., 33.5, 34.,  34.5, 35.5, 36.5,
      37.,  37.5, 37.,  37.5, 38., 39.,  40.,  40.5, 41.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID1x7x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {17., 18., 19., 24., 25.,
                                         26., 31., 32., 33.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME1x7x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17., 18., 18., 19., 19., 20., 21., 22., 23., 24., 24., 25., 25., 26.,
      24., 25., 25., 26., 26., 27., 28., 29., 30., 31., 31., 32., 32., 33.,
      31., 32., 32., 33., 33., 34., 35., 36., 37., 38., 38., 39., 39., 40.,
      45., 46., 46., 47., 47., 48., 49., 50., 51., 52., 52., 53., 53., 54.,
      59., 60., 60., 61., 61., 62., 63., 64., 65., 66., 66., 67., 67., 68.,
      66., 67., 67., 68., 68., 69., 70., 71., 72., 73., 73., 74., 74., 75.,
      73., 74., 74., 75., 75., 76., 77., 78., 79., 80., 80., 81., 81., 82.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID1x7x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {33., 34., 35., 36., 37., 38.,
                                         47., 48., 49., 50., 51., 52.,
                                         61., 62., 63., 64., 65., 66.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME1x7x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      33.,  34.,  35.,  36.,  35.,  36.,  37.,  38.,  37.,  38.,  39.,  40.,
      41.,  42.,  43.,  44.,  45.,  46.,  47.,  48.,  47.,  48.,  49.,  50.,
      49.,  50.,  51.,  52.,  47.,  48.,  49.,  50.,  49.,  50.,  51.,  52.,
      51.,  52.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,  61.,  62.,
      61.,  62.,  63.,  64.,  63.,  64.,  65.,  66.,  61.,  62.,  63.,  64.,
      63.,  64.,  65.,  66.,  65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,
      73.,  74.,  75.,  76.,  75.,  76.,  77.,  78.,  77.,  78.,  79.,  80.,
      89.,  90.,  91.,  92.,  91.,  92.,  93.,  94.,  93.,  94.,  95.,  96.,
      97.,  98.,  99.,  100., 101., 102., 103., 104., 103., 104., 105., 106.,
      105., 106., 107., 108., 117., 118., 119., 120., 119., 120., 121., 122.,
      121., 122., 123., 124., 125., 126., 127., 128., 129., 130., 131., 132.,
      131., 132., 133., 134., 133., 134., 135., 136., 131., 132., 133., 134.,
      133., 134., 135., 136., 135., 136., 137., 138., 139., 140., 141., 142.,
      143., 144., 145., 146., 145., 146., 147., 148., 147., 148., 149., 150.,
      145., 146., 147., 148., 147., 148., 149., 150., 149., 150., 151., 152.,
      153., 154., 155., 156., 157., 158., 159., 160., 159., 160., 161., 162.,
      161., 162., 163., 164.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID1x7x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,  73.,  74.,  75.,  76.,
      93.,  94.,  95.,  96.,  97.,  98.,  99.,  100., 101., 102., 103., 104.,
      121., 122., 123., 124., 125., 126., 127., 128., 129., 130., 131., 132.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME1x7x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10., 10.5, 11.,  12., 13., 14.,  14.5, 15., 14., 14.5, 15.,  16.,
      17., 18.,  18.5, 19., 18., 18.5, 19.,  20., 21., 22.,  22.5, 23.,
      26., 26.5, 27.,  28., 29., 30.,  30.5, 31., 34., 34.5, 35.,  36.,
      37., 38.,  38.5, 39., 38., 38.5, 39.,  40., 41., 42.,  42.5, 43.,
      42., 42.5, 43.,  44., 45., 46.,  46.5, 47.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID1x7x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {19., 20., 21., 22., 27., 28.,
                                         29., 30., 35., 36., 37., 38.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME1x7x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19., 20., 20., 21., 21., 22., 23., 24., 25., 26., 27., 28., 28., 29.,
      29., 30., 27., 28., 28., 29., 29., 30., 31., 32., 33., 34., 35., 36.,
      36., 37., 37., 38., 35., 36., 36., 37., 37., 38., 39., 40., 41., 42.,
      43., 44., 44., 45., 45., 46., 51., 52., 52., 53., 53., 54., 55., 56.,
      57., 58., 59., 60., 60., 61., 61., 62., 67., 68., 68., 69., 69., 70.,
      71., 72., 73., 74., 75., 76., 76., 77., 77., 78., 75., 76., 76., 77.,
      77., 78., 79., 80., 81., 82., 83., 84., 84., 85., 85., 86., 83., 84.,
      84., 85., 85., 86., 87., 88., 89., 90., 91., 92., 92., 93., 93., 94.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID1x7x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      37., 38., 39., 40., 41., 42., 43., 44., 53., 54., 55., 56.,
      57., 58., 59., 60., 69., 70., 71., 72., 73., 74., 75., 76.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME1x7x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      37.,  38.,  39.,  40.,  39.,  40.,  41.,  42.,  41.,  42.,  43.,  44.,
      45.,  46.,  47.,  48.,  49.,  50.,  51.,  52.,  53.,  54.,  55.,  56.,
      55.,  56.,  57.,  58.,  57.,  58.,  59.,  60.,  53.,  54.,  55.,  56.,
      55.,  56.,  57.,  58.,  57.,  58.,  59.,  60.,  61.,  62.,  63.,  64.,
      65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,  71.,  72.,  73.,  74.,
      73.,  74.,  75.,  76.,  69.,  70.,  71.,  72.,  71.,  72.,  73.,  74.,
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,
      85.,  86.,  87.,  88.,  87.,  88.,  89.,  90.,  89.,  90.,  91.,  92.,
      101., 102., 103., 104., 103., 104., 105., 106., 105., 106., 107., 108.,
      109., 110., 111., 112., 113., 114., 115., 116., 117., 118., 119., 120.,
      119., 120., 121., 122., 121., 122., 123., 124., 133., 134., 135., 136.,
      135., 136., 137., 138., 137., 138., 139., 140., 141., 142., 143., 144.,
      145., 146., 147., 148., 149., 150., 151., 152., 151., 152., 153., 154.,
      153., 154., 155., 156., 149., 150., 151., 152., 151., 152., 153., 154.,
      153., 154., 155., 156., 157., 158., 159., 160., 161., 162., 163., 164.,
      165., 166., 167., 168., 167., 168., 169., 170., 169., 170., 171., 172.,
      165., 166., 167., 168., 167., 168., 169., 170., 169., 170., 171., 172.,
      173., 174., 175., 176., 177., 178., 179., 180., 181., 182., 183., 184.,
      183., 184., 185., 186., 185., 186., 187., 188.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID1x7x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,
      85.,  86.,  87.,  88.,  105., 106., 107., 108., 109., 110., 111., 112.,
      113., 114., 115., 116., 117., 118., 119., 120., 137., 138., 139., 140.,
      141., 142., 143., 144., 145., 146., 147., 148., 149., 150., 151., 152.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME1x8x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8.,  8.5,  9.,  10., 10.5, 11., 11., 11.5, 12., 13., 13.5, 14.,
      14., 14.5, 15., 16., 16.5, 17., 20., 20.5, 21., 22., 22.5, 23.,
      26., 26.5, 27., 28., 28.5, 29., 32., 32.5, 33., 34., 34.5, 35.,
      35., 35.5, 36., 37., 37.5, 38., 38., 38.5, 39., 40., 40.5, 41.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID1x8x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {15., 16., 21., 22.,
                                         27., 28., 33., 34.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME1x8x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15., 16., 16., 17., 17., 18., 19., 20., 20., 21., 21., 22., 21., 22.,
      22., 23., 23., 24., 25., 26., 26., 27., 27., 28., 27., 28., 28., 29.,
      29., 30., 31., 32., 32., 33., 33., 34., 39., 40., 40., 41., 41., 42.,
      43., 44., 44., 45., 45., 46., 51., 52., 52., 53., 53., 54., 55., 56.,
      56., 57., 57., 58., 63., 64., 64., 65., 65., 66., 67., 68., 68., 69.,
      69., 70., 69., 70., 70., 71., 71., 72., 73., 74., 74., 75., 75., 76.,
      75., 76., 76., 77., 77., 78., 79., 80., 80., 81., 81., 82.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID1x8x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {29., 30., 31., 32., 41., 42.,
                                         43., 44., 53., 54., 55., 56.,
                                         65., 66., 67., 68.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME1x8x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29.,  30.,  31.,  32.,  31.,  32.,  33.,  34.,  33.,  34.,  35.,  36.,
      37.,  38.,  39.,  40.,  39.,  40.,  41.,  42.,  41.,  42.,  43.,  44.,
      41.,  42.,  43.,  44.,  43.,  44.,  45.,  46.,  45.,  46.,  47.,  48.,
      49.,  50.,  51.,  52.,  51.,  52.,  53.,  54.,  53.,  54.,  55.,  56.,
      53.,  54.,  55.,  56.,  55.,  56.,  57.,  58.,  57.,  58.,  59.,  60.,
      61.,  62.,  63.,  64.,  63.,  64.,  65.,  66.,  65.,  66.,  67.,  68.,
      77.,  78.,  79.,  80.,  79.,  80.,  81.,  82.,  81.,  82.,  83.,  84.,
      85.,  86.,  87.,  88.,  87.,  88.,  89.,  90.,  89.,  90.,  91.,  92.,
      101., 102., 103., 104., 103., 104., 105., 106., 105., 106., 107., 108.,
      109., 110., 111., 112., 111., 112., 113., 114., 113., 114., 115., 116.,
      125., 126., 127., 128., 127., 128., 129., 130., 129., 130., 131., 132.,
      133., 134., 135., 136., 135., 136., 137., 138., 137., 138., 139., 140.,
      137., 138., 139., 140., 139., 140., 141., 142., 141., 142., 143., 144.,
      145., 146., 147., 148., 147., 148., 149., 150., 149., 150., 151., 152.,
      149., 150., 151., 152., 151., 152., 153., 154., 153., 154., 155., 156.,
      157., 158., 159., 160., 159., 160., 161., 162., 161., 162., 163., 164.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID1x8x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      57.,  58.,  59.,  60.,  61.,  62.,  63.,  64.,  81.,  82.,  83.,
      84.,  85.,  86.,  87.,  88.,  105., 106., 107., 108., 109., 110.,
      111., 112., 129., 130., 131., 132., 133., 134., 135., 136.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME1x8x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9.,   9.5,  10.,  11.,  12.,  12.5, 13.,  12.5, 13.,  13.5, 14.5, 15.5,
      16.,  16.5, 16.,  16.5, 17.,  18.,  19.,  19.5, 20.,  23.,  23.5, 24.,
      25.,  26.,  26.5, 27.,  30.,  30.5, 31.,  32.,  33.,  33.5, 34.,  37.,
      37.5, 38.,  39.,  40.,  40.5, 41.,  40.5, 41.,  41.5, 42.5, 43.5, 44.,
      44.5, 44.,  44.5, 45.,  46.,  47.,  47.5, 48.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID1x8x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {17., 18., 19., 24., 25., 26.,
                                         31., 32., 33., 38., 39., 40.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME1x8x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17., 18., 18., 19., 19., 20., 21., 22., 23., 24., 24., 25., 25., 26.,
      24., 25., 25., 26., 26., 27., 28., 29., 30., 31., 31., 32., 32., 33.,
      31., 32., 32., 33., 33., 34., 35., 36., 37., 38., 38., 39., 39., 40.,
      45., 46., 46., 47., 47., 48., 49., 50., 51., 52., 52., 53., 53., 54.,
      59., 60., 60., 61., 61., 62., 63., 64., 65., 66., 66., 67., 67., 68.,
      73., 74., 74., 75., 75., 76., 77., 78., 79., 80., 80., 81., 81., 82.,
      80., 81., 81., 82., 82., 83., 84., 85., 86., 87., 87., 88., 88., 89.,
      87., 88., 88., 89., 89., 90., 91., 92., 93., 94., 94., 95., 95., 96.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID1x8x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      33., 34., 35., 36., 37., 38., 47., 48., 49., 50., 51., 52.,
      61., 62., 63., 64., 65., 66., 75., 76., 77., 78., 79., 80.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME1x8x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      33.,  34.,  35.,  36.,  35.,  36.,  37.,  38.,  37.,  38.,  39.,  40.,
      41.,  42.,  43.,  44.,  45.,  46.,  47.,  48.,  47.,  48.,  49.,  50.,
      49.,  50.,  51.,  52.,  47.,  48.,  49.,  50.,  49.,  50.,  51.,  52.,
      51.,  52.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,  61.,  62.,
      61.,  62.,  63.,  64.,  63.,  64.,  65.,  66.,  61.,  62.,  63.,  64.,
      63.,  64.,  65.,  66.,  65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,
      73.,  74.,  75.,  76.,  75.,  76.,  77.,  78.,  77.,  78.,  79.,  80.,
      89.,  90.,  91.,  92.,  91.,  92.,  93.,  94.,  93.,  94.,  95.,  96.,
      97.,  98.,  99.,  100., 101., 102., 103., 104., 103., 104., 105., 106.,
      105., 106., 107., 108., 117., 118., 119., 120., 119., 120., 121., 122.,
      121., 122., 123., 124., 125., 126., 127., 128., 129., 130., 131., 132.,
      131., 132., 133., 134., 133., 134., 135., 136., 145., 146., 147., 148.,
      147., 148., 149., 150., 149., 150., 151., 152., 153., 154., 155., 156.,
      157., 158., 159., 160., 159., 160., 161., 162., 161., 162., 163., 164.,
      159., 160., 161., 162., 161., 162., 163., 164., 163., 164., 165., 166.,
      167., 168., 169., 170., 171., 172., 173., 174., 173., 174., 175., 176.,
      175., 176., 177., 178., 173., 174., 175., 176., 175., 176., 177., 178.,
      177., 178., 179., 180., 181., 182., 183., 184., 185., 186., 187., 188.,
      187., 188., 189., 190., 189., 190., 191., 192.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID1x8x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,  73.,  74.,  75.,  76.,
      93.,  94.,  95.,  96.,  97.,  98.,  99.,  100., 101., 102., 103., 104.,
      121., 122., 123., 124., 125., 126., 127., 128., 129., 130., 131., 132.,
      149., 150., 151., 152., 153., 154., 155., 156., 157., 158., 159., 160.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME1x8x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10., 10.5, 11.,  12., 13.,  14.,  14.5, 15.,  14., 14.5, 15.,  16., 17.,
      18., 18.5, 19.,  18., 18.5, 19.,  20.,  21.,  22., 22.5, 23.,  26., 26.5,
      27., 28.,  29.,  30., 30.5, 31.,  34.,  34.5, 35., 36.,  37.,  38., 38.5,
      39., 42.,  42.5, 43., 44.,  45.,  46.,  46.5, 47., 46.,  46.5, 47., 48.,
      49., 50.,  50.5, 51., 50.,  50.5, 51.,  52.,  53., 54.,  54.5, 55.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID1x8x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {19., 20., 21., 22., 27., 28.,
                                         29., 30., 35., 36., 37., 38.,
                                         43., 44., 45., 46.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME1x8x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19.,  20.,  20.,  21.,  21.,  22.,  23.,  24.,  25.,  26.,  27.,  28.,
      28.,  29.,  29.,  30.,  27.,  28.,  28.,  29.,  29.,  30.,  31.,  32.,
      33.,  34.,  35.,  36.,  36.,  37.,  37.,  38.,  35.,  36.,  36.,  37.,
      37.,  38.,  39.,  40.,  41.,  42.,  43.,  44.,  44.,  45.,  45.,  46.,
      51.,  52.,  52.,  53.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,
      60.,  61.,  61.,  62.,  67.,  68.,  68.,  69.,  69.,  70.,  71.,  72.,
      73.,  74.,  75.,  76.,  76.,  77.,  77.,  78.,  83.,  84.,  84.,  85.,
      85.,  86.,  87.,  88.,  89.,  90.,  91.,  92.,  92.,  93.,  93.,  94.,
      91.,  92.,  92.,  93.,  93.,  94.,  95.,  96.,  97.,  98.,  99.,  100.,
      100., 101., 101., 102., 99.,  100., 100., 101., 101., 102., 103., 104.,
      105., 106., 107., 108., 108., 109., 109., 110.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID1x8x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      37., 38., 39., 40., 41., 42., 43., 44., 53., 54., 55.,
      56., 57., 58., 59., 60., 69., 70., 71., 72., 73., 74.,
      75., 76., 85., 86., 87., 88., 89., 90., 91., 92.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME1x8x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      37.,  38.,  39.,  40.,  39.,  40.,  41.,  42.,  41.,  42.,  43.,  44.,
      45.,  46.,  47.,  48.,  49.,  50.,  51.,  52.,  53.,  54.,  55.,  56.,
      55.,  56.,  57.,  58.,  57.,  58.,  59.,  60.,  53.,  54.,  55.,  56.,
      55.,  56.,  57.,  58.,  57.,  58.,  59.,  60.,  61.,  62.,  63.,  64.,
      65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,  71.,  72.,  73.,  74.,
      73.,  74.,  75.,  76.,  69.,  70.,  71.,  72.,  71.,  72.,  73.,  74.,
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,
      85.,  86.,  87.,  88.,  87.,  88.,  89.,  90.,  89.,  90.,  91.,  92.,
      101., 102., 103., 104., 103., 104., 105., 106., 105., 106., 107., 108.,
      109., 110., 111., 112., 113., 114., 115., 116., 117., 118., 119., 120.,
      119., 120., 121., 122., 121., 122., 123., 124., 133., 134., 135., 136.,
      135., 136., 137., 138., 137., 138., 139., 140., 141., 142., 143., 144.,
      145., 146., 147., 148., 149., 150., 151., 152., 151., 152., 153., 154.,
      153., 154., 155., 156., 165., 166., 167., 168., 167., 168., 169., 170.,
      169., 170., 171., 172., 173., 174., 175., 176., 177., 178., 179., 180.,
      181., 182., 183., 184., 183., 184., 185., 186., 185., 186., 187., 188.,
      181., 182., 183., 184., 183., 184., 185., 186., 185., 186., 187., 188.,
      189., 190., 191., 192., 193., 194., 195., 196., 197., 198., 199., 200.,
      199., 200., 201., 202., 201., 202., 203., 204., 197., 198., 199., 200.,
      199., 200., 201., 202., 201., 202., 203., 204., 205., 206., 207., 208.,
      209., 210., 211., 212., 213., 214., 215., 216., 215., 216., 217., 218.,
      217., 218., 219., 220.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID1x8x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  81.,  82.,  83.,
      84.,  85.,  86.,  87.,  88.,  105., 106., 107., 108., 109., 110.,
      111., 112., 113., 114., 115., 116., 117., 118., 119., 120., 137.,
      138., 139., 140., 141., 142., 143., 144., 145., 146., 147., 148.,
      149., 150., 151., 152., 169., 170., 171., 172., 173., 174., 175.,
      176., 177., 178., 179., 180., 181., 182., 183., 184.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME3x6x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8.,  8.5,  9.,  10., 10.5, 11., 11., 11.5, 12., 13.,  13.5,  14.,
      14., 14.5, 15., 16., 16.5, 17., 20., 20.5, 21., 22.,  22.5,  23.,
      23., 23.5, 24., 25., 25.5, 26., 26., 26.5, 27., 28.,  28.5,  29.,
      44., 44.5, 45., 46., 46.5, 47., 47., 47.5, 48., 49.,  49.5,  50.,
      50., 50.5, 51., 52., 52.5, 53., 56., 56.5, 57., 58.,  58.5,  59.,
      59., 59.5, 60., 61., 61.5, 62., 62., 62.5, 63., 64.,  64.5,  65.,
      80., 80.5, 81., 82., 82.5, 83., 83., 83.5, 84., 85.,  85.5,  86.,
      86., 86.5, 87., 88., 88.5, 89., 92., 92.5, 93., 94.,  94.5,  95.,
      95., 95.5, 96., 97., 97.5, 98., 98., 98.5, 99., 100., 100.5, 101.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID3x6x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {15., 16., 21., 22., 51., 52.,
                                         57., 58., 87., 88., 93., 94.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME3x6x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15.,  16.,  16.,  17.,  17.,  18.,  19.,  20.,  20.,  21.,  21.,  22.,
      21.,  22.,  22.,  23.,  23.,  24.,  25.,  26.,  26.,  27.,  27.,  28.,
      27.,  28.,  28.,  29.,  29.,  30.,  31.,  32.,  32.,  33.,  33.,  34.,
      39.,  40.,  40.,  41.,  41.,  42.,  43.,  44.,  44.,  45.,  45.,  46.,
      45.,  46.,  46.,  47.,  47.,  48.,  49.,  50.,  50.,  51.,  51.,  52.,
      51.,  52.,  52.,  53.,  53.,  54.,  55.,  56.,  56.,  57.,  57.,  58.,
      87.,  88.,  88.,  89.,  89.,  90.,  91.,  92.,  92.,  93.,  93.,  94.,
      93.,  94.,  94.,  95.,  95.,  96.,  97.,  98.,  98.,  99.,  99.,  100.,
      99.,  100., 100., 101., 101., 102., 103., 104., 104., 105., 105., 106.,
      111., 112., 112., 113., 113., 114., 115., 116., 116., 117., 117., 118.,
      117., 118., 118., 119., 119., 120., 121., 122., 122., 123., 123., 124.,
      123., 124., 124., 125., 125., 126., 127., 128., 128., 129., 129., 130.,
      159., 160., 160., 161., 161., 162., 163., 164., 164., 165., 165., 166.,
      165., 166., 166., 167., 167., 168., 169., 170., 170., 171., 171., 172.,
      171., 172., 172., 173., 173., 174., 175., 176., 176., 177., 177., 178.,
      183., 184., 184., 185., 185., 186., 187., 188., 188., 189., 189., 190.,
      189., 190., 190., 191., 191., 192., 193., 194., 194., 195., 195., 196.,
      195., 196., 196., 197., 197., 198., 199., 200., 200., 201., 201., 202.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID3x6x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29.,  30.,  31.,  32.,  41.,  42.,  43.,  44.,  101., 102., 103., 104.,
      113., 114., 115., 116., 173., 174., 175., 176., 185., 186., 187., 188.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME3x6x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29.,  30.,  31.,  32.,  31.,  32.,  33.,  34.,  33.,  34.,  35.,  36.,
      37.,  38.,  39.,  40.,  39.,  40.,  41.,  42.,  41.,  42.,  43.,  44.,
      41.,  42.,  43.,  44.,  43.,  44.,  45.,  46.,  45.,  46.,  47.,  48.,
      49.,  50.,  51.,  52.,  51.,  52.,  53.,  54.,  53.,  54.,  55.,  56.,
      53.,  54.,  55.,  56.,  55.,  56.,  57.,  58.,  57.,  58.,  59.,  60.,
      61.,  62.,  63.,  64.,  63.,  64.,  65.,  66.,  65.,  66.,  67.,  68.,
      77.,  78.,  79.,  80.,  79.,  80.,  81.,  82.,  81.,  82.,  83.,  84.,
      85.,  86.,  87.,  88.,  87.,  88.,  89.,  90.,  89.,  90.,  91.,  92.,
      89.,  90.,  91.,  92.,  91.,  92.,  93.,  94.,  93.,  94.,  95.,  96.,
      97.,  98.,  99.,  100., 99.,  100., 101., 102., 101., 102., 103., 104.,
      101., 102., 103., 104., 103., 104., 105., 106., 105., 106., 107., 108.,
      109., 110., 111., 112., 111., 112., 113., 114., 113., 114., 115., 116.,
      173., 174., 175., 176., 175., 176., 177., 178., 177., 178., 179., 180.,
      181., 182., 183., 184., 183., 184., 185., 186., 185., 186., 187., 188.,
      185., 186., 187., 188., 187., 188., 189., 190., 189., 190., 191., 192.,
      193., 194., 195., 196., 195., 196., 197., 198., 197., 198., 199., 200.,
      197., 198., 199., 200., 199., 200., 201., 202., 201., 202., 203., 204.,
      205., 206., 207., 208., 207., 208., 209., 210., 209., 210., 211., 212.,
      221., 222., 223., 224., 223., 224., 225., 226., 225., 226., 227., 228.,
      229., 230., 231., 232., 231., 232., 233., 234., 233., 234., 235., 236.,
      233., 234., 235., 236., 235., 236., 237., 238., 237., 238., 239., 240.,
      241., 242., 243., 244., 243., 244., 245., 246., 245., 246., 247., 248.,
      245., 246., 247., 248., 247., 248., 249., 250., 249., 250., 251., 252.,
      253., 254., 255., 256., 255., 256., 257., 258., 257., 258., 259., 260.,
      317., 318., 319., 320., 319., 320., 321., 322., 321., 322., 323., 324.,
      325., 326., 327., 328., 327., 328., 329., 330., 329., 330., 331., 332.,
      329., 330., 331., 332., 331., 332., 333., 334., 333., 334., 335., 336.,
      337., 338., 339., 340., 339., 340., 341., 342., 341., 342., 343., 344.,
      341., 342., 343., 344., 343., 344., 345., 346., 345., 346., 347., 348.,
      349., 350., 351., 352., 351., 352., 353., 354., 353., 354., 355., 356.,
      365., 366., 367., 368., 367., 368., 369., 370., 369., 370., 371., 372.,
      373., 374., 375., 376., 375., 376., 377., 378., 377., 378., 379., 380.,
      377., 378., 379., 380., 379., 380., 381., 382., 381., 382., 383., 384.,
      385., 386., 387., 388., 387., 388., 389., 390., 389., 390., 391., 392.,
      389., 390., 391., 392., 391., 392., 393., 394., 393., 394., 395., 396.,
      397., 398., 399., 400., 399., 400., 401., 402., 401., 402., 403., 404.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID3x6x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      57.,  58.,  59.,  60.,  61.,  62.,  63.,  64.,  81.,  82.,  83.,  84.,
      85.,  86.,  87.,  88.,  201., 202., 203., 204., 205., 206., 207., 208.,
      225., 226., 227., 228., 229., 230., 231., 232., 345., 346., 347., 348.,
      349., 350., 351., 352., 369., 370., 371., 372., 373., 374., 375., 376.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME3x6x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9.,    9.5,  10.,   11.,   12.,   12.5,  13.,   12.5,  13.,   13.5,
      14.5,  15.5, 16.,   16.5,  16.,   16.5,  17.,   18.,   19.,   19.5,
      20.,   23.,  23.5,  24.,   25.,   26.,   26.5,  27.,   26.5,  27.,
      27.5,  28.5, 29.5,  30.,   30.5,  30.,   30.5,  31.,   32.,   33.,
      33.5,  34.,  51.,   51.5,  52.,   53.,   54.,   54.5,  55.,   54.5,
      55.,   55.5, 56.5,  57.5,  58.,   58.5,  58.,   58.5,  59.,   60.,
      61.,   61.5, 62.,   65.,   65.5,  66.,   67.,   68.,   68.5,  69.,
      68.5,  69.,  69.5,  70.5,  71.5,  72.,   72.5,  72.,   72.5,  73.,
      74.,   75.,  75.5,  76.,   93.,   93.5,  94.,   95.,   96.,   96.5,
      97.,   96.5, 97.,   97.5,  98.5,  99.5,  100.,  100.5, 100.,  100.5,
      101.,  102., 103.,  103.5, 104.,  107.,  107.5, 108.,  109.,  110.,
      110.5, 111., 110.5, 111.,  111.5, 112.5, 113.5, 114.,  114.5, 114.,
      114.5, 115., 116.,  117.,  117.5, 118.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID3x6x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {17.,  18.,  19.,  24.,  25.,  26.,
                                         59.,  60.,  61.,  66.,  67.,  68.,
                                         101., 102., 103., 108., 109., 110.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME3x6x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17.,  18.,  18.,  19.,  19.,  20.,  21.,  22.,  23.,  24.,  24.,  25.,
      25.,  26.,  24.,  25.,  25.,  26.,  26.,  27.,  28.,  29.,  30.,  31.,
      31.,  32.,  32.,  33.,  31.,  32.,  32.,  33.,  33.,  34.,  35.,  36.,
      37.,  38.,  38.,  39.,  39.,  40.,  45.,  46.,  46.,  47.,  47.,  48.,
      49.,  50.,  51.,  52.,  52.,  53.,  53.,  54.,  52.,  53.,  53.,  54.,
      54.,  55.,  56.,  57.,  58.,  59.,  59.,  60.,  60.,  61.,  59.,  60.,
      60.,  61.,  61.,  62.,  63.,  64.,  65.,  66.,  66.,  67.,  67.,  68.,
      101., 102., 102., 103., 103., 104., 105., 106., 107., 108., 108., 109.,
      109., 110., 108., 109., 109., 110., 110., 111., 112., 113., 114., 115.,
      115., 116., 116., 117., 115., 116., 116., 117., 117., 118., 119., 120.,
      121., 122., 122., 123., 123., 124., 129., 130., 130., 131., 131., 132.,
      133., 134., 135., 136., 136., 137., 137., 138., 136., 137., 137., 138.,
      138., 139., 140., 141., 142., 143., 143., 144., 144., 145., 143., 144.,
      144., 145., 145., 146., 147., 148., 149., 150., 150., 151., 151., 152.,
      185., 186., 186., 187., 187., 188., 189., 190., 191., 192., 192., 193.,
      193., 194., 192., 193., 193., 194., 194., 195., 196., 197., 198., 199.,
      199., 200., 200., 201., 199., 200., 200., 201., 201., 202., 203., 204.,
      205., 206., 206., 207., 207., 208., 213., 214., 214., 215., 215., 216.,
      217., 218., 219., 220., 220., 221., 221., 222., 220., 221., 221., 222.,
      222., 223., 224., 225., 226., 227., 227., 228., 228., 229., 227., 228.,
      228., 229., 229., 230., 231., 232., 233., 234., 234., 235., 235., 236.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID3x6x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      33.,  34.,  35.,  36.,  37.,  38.,  47.,  48.,  49.,  50.,  51.,  52.,
      117., 118., 119., 120., 121., 122., 131., 132., 133., 134., 135., 136.,
      201., 202., 203., 204., 205., 206., 215., 216., 217., 218., 219., 220.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME3x6x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      33.,  34.,  35.,  36.,  35.,  36.,  37.,  38.,  37.,  38.,  39.,  40.,
      41.,  42.,  43.,  44.,  45.,  46.,  47.,  48.,  47.,  48.,  49.,  50.,
      49.,  50.,  51.,  52.,  47.,  48.,  49.,  50.,  49.,  50.,  51.,  52.,
      51.,  52.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,  61.,  62.,
      61.,  62.,  63.,  64.,  63.,  64.,  65.,  66.,  61.,  62.,  63.,  64.,
      63.,  64.,  65.,  66.,  65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,
      73.,  74.,  75.,  76.,  75.,  76.,  77.,  78.,  77.,  78.,  79.,  80.,
      89.,  90.,  91.,  92.,  91.,  92.,  93.,  94.,  93.,  94.,  95.,  96.,
      97.,  98.,  99.,  100., 101., 102., 103., 104., 103., 104., 105., 106.,
      105., 106., 107., 108., 103., 104., 105., 106., 105., 106., 107., 108.,
      107., 108., 109., 110., 111., 112., 113., 114., 115., 116., 117., 118.,
      117., 118., 119., 120., 119., 120., 121., 122., 117., 118., 119., 120.,
      119., 120., 121., 122., 121., 122., 123., 124., 125., 126., 127., 128.,
      129., 130., 131., 132., 131., 132., 133., 134., 133., 134., 135., 136.,
      201., 202., 203., 204., 203., 204., 205., 206., 205., 206., 207., 208.,
      209., 210., 211., 212., 213., 214., 215., 216., 215., 216., 217., 218.,
      217., 218., 219., 220., 215., 216., 217., 218., 217., 218., 219., 220.,
      219., 220., 221., 222., 223., 224., 225., 226., 227., 228., 229., 230.,
      229., 230., 231., 232., 231., 232., 233., 234., 229., 230., 231., 232.,
      231., 232., 233., 234., 233., 234., 235., 236., 237., 238., 239., 240.,
      241., 242., 243., 244., 243., 244., 245., 246., 245., 246., 247., 248.,
      257., 258., 259., 260., 259., 260., 261., 262., 261., 262., 263., 264.,
      265., 266., 267., 268., 269., 270., 271., 272., 271., 272., 273., 274.,
      273., 274., 275., 276., 271., 272., 273., 274., 273., 274., 275., 276.,
      275., 276., 277., 278., 279., 280., 281., 282., 283., 284., 285., 286.,
      285., 286., 287., 288., 287., 288., 289., 290., 285., 286., 287., 288.,
      287., 288., 289., 290., 289., 290., 291., 292., 293., 294., 295., 296.,
      297., 298., 299., 300., 299., 300., 301., 302., 301., 302., 303., 304.,
      369., 370., 371., 372., 371., 372., 373., 374., 373., 374., 375., 376.,
      377., 378., 379., 380., 381., 382., 383., 384., 383., 384., 385., 386.,
      385., 386., 387., 388., 383., 384., 385., 386., 385., 386., 387., 388.,
      387., 388., 389., 390., 391., 392., 393., 394., 395., 396., 397., 398.,
      397., 398., 399., 400., 399., 400., 401., 402., 397., 398., 399., 400.,
      399., 400., 401., 402., 401., 402., 403., 404., 405., 406., 407., 408.,
      409., 410., 411., 412., 411., 412., 413., 414., 413., 414., 415., 416.,
      425., 426., 427., 428., 427., 428., 429., 430., 429., 430., 431., 432.,
      433., 434., 435., 436., 437., 438., 439., 440., 439., 440., 441., 442.,
      441., 442., 443., 444., 439., 440., 441., 442., 441., 442., 443., 444.,
      443., 444., 445., 446., 447., 448., 449., 450., 451., 452., 453., 454.,
      453., 454., 455., 456., 455., 456., 457., 458., 453., 454., 455., 456.,
      455., 456., 457., 458., 457., 458., 459., 460., 461., 462., 463., 464.,
      465., 466., 467., 468., 467., 468., 469., 470., 469., 470., 471., 472.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID3x6x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,  73.,  74.,  75.,  76.,
      93.,  94.,  95.,  96.,  97.,  98.,  99.,  100., 101., 102., 103., 104.,
      233., 234., 235., 236., 237., 238., 239., 240., 241., 242., 243., 244.,
      261., 262., 263., 264., 265., 266., 267., 268., 269., 270., 271., 272.,
      401., 402., 403., 404., 405., 406., 407., 408., 409., 410., 411., 412.,
      429., 430., 431., 432., 433., 434., 435., 436., 437., 438., 439., 440.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME3x6x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10.,   10.5, 11.,   12.,   13.,  14.,   14.5,  15.,  14.,   14.5,  15.,
      16.,   17.,  18.,   18.5,  19.,  18.,   18.5,  19.,  20.,   21.,   22.,
      22.5,  23.,  26.,   26.5,  27.,  28.,   29.,   30.,  30.5,  31.,   30.,
      30.5,  31.,  32.,   33.,   34.,  34.5,  35.,   34.,  34.5,  35.,   36.,
      37.,   38.,  38.5,  39.,   58.,  58.5,  59.,   60.,  61.,   62.,   62.5,
      63.,   62.,  62.5,  63.,   64.,  65.,   66.,   66.5, 67.,   66.,   66.5,
      67.,   68.,  69.,   70.,   70.5, 71.,   74.,   74.5, 75.,   76.,   77.,
      78.,   78.5, 79.,   78.,   78.5, 79.,   80.,   81.,  82.,   82.5,  83.,
      82.,   82.5, 83.,   84.,   85.,  86.,   86.5,  87.,  106.,  106.5, 107.,
      108.,  109., 110.,  110.5, 111., 110.,  110.5, 111., 112.,  113.,  114.,
      114.5, 115., 114.,  114.5, 115., 116.,  117.,  118., 118.5, 119.,  122.,
      122.5, 123., 124.,  125.,  126., 126.5, 127.,  126., 126.5, 127.,  128.,
      129.,  130., 130.5, 131.,  130., 130.5, 131.,  132., 133.,  134.,  134.5,
      135.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID3x6x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19., 20., 21., 22., 27.,  28.,  29.,  30.,  67.,  68.,  69.,  70.,
      75., 76., 77., 78., 115., 116., 117., 118., 123., 124., 125., 126.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME3x6x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19.,  20.,  20.,  21.,  21.,  22.,  23.,  24.,  25.,  26.,  27.,  28.,
      28.,  29.,  29.,  30.,  27.,  28.,  28.,  29.,  29.,  30.,  31.,  32.,
      33.,  34.,  35.,  36.,  36.,  37.,  37.,  38.,  35.,  36.,  36.,  37.,
      37.,  38.,  39.,  40.,  41.,  42.,  43.,  44.,  44.,  45.,  45.,  46.,
      51.,  52.,  52.,  53.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,
      60.,  61.,  61.,  62.,  59.,  60.,  60.,  61.,  61.,  62.,  63.,  64.,
      65.,  66.,  67.,  68.,  68.,  69.,  69.,  70.,  67.,  68.,  68.,  69.,
      69.,  70.,  71.,  72.,  73.,  74.,  75.,  76.,  76.,  77.,  77.,  78.,
      115., 116., 116., 117., 117., 118., 119., 120., 121., 122., 123., 124.,
      124., 125., 125., 126., 123., 124., 124., 125., 125., 126., 127., 128.,
      129., 130., 131., 132., 132., 133., 133., 134., 131., 132., 132., 133.,
      133., 134., 135., 136., 137., 138., 139., 140., 140., 141., 141., 142.,
      147., 148., 148., 149., 149., 150., 151., 152., 153., 154., 155., 156.,
      156., 157., 157., 158., 155., 156., 156., 157., 157., 158., 159., 160.,
      161., 162., 163., 164., 164., 165., 165., 166., 163., 164., 164., 165.,
      165., 166., 167., 168., 169., 170., 171., 172., 172., 173., 173., 174.,
      211., 212., 212., 213., 213., 214., 215., 216., 217., 218., 219., 220.,
      220., 221., 221., 222., 219., 220., 220., 221., 221., 222., 223., 224.,
      225., 226., 227., 228., 228., 229., 229., 230., 227., 228., 228., 229.,
      229., 230., 231., 232., 233., 234., 235., 236., 236., 237., 237., 238.,
      243., 244., 244., 245., 245., 246., 247., 248., 249., 250., 251., 252.,
      252., 253., 253., 254., 251., 252., 252., 253., 253., 254., 255., 256.,
      257., 258., 259., 260., 260., 261., 261., 262., 259., 260., 260., 261.,
      261., 262., 263., 264., 265., 266., 267., 268., 268., 269., 269., 270.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID3x6x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      37.,  38.,  39.,  40.,  41.,  42.,  43.,  44.,  53.,  54.,  55.,  56.,
      57.,  58.,  59.,  60.,  133., 134., 135., 136., 137., 138., 139., 140.,
      149., 150., 151., 152., 153., 154., 155., 156., 229., 230., 231., 232.,
      233., 234., 235., 236., 245., 246., 247., 248., 249., 250., 251., 252.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME3x6x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      37.,  38.,  39.,  40.,  39.,  40.,  41.,  42.,  41.,  42.,  43.,  44.,
      45.,  46.,  47.,  48.,  49.,  50.,  51.,  52.,  53.,  54.,  55.,  56.,
      55.,  56.,  57.,  58.,  57.,  58.,  59.,  60.,  53.,  54.,  55.,  56.,
      55.,  56.,  57.,  58.,  57.,  58.,  59.,  60.,  61.,  62.,  63.,  64.,
      65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,  71.,  72.,  73.,  74.,
      73.,  74.,  75.,  76.,  69.,  70.,  71.,  72.,  71.,  72.,  73.,  74.,
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,
      85.,  86.,  87.,  88.,  87.,  88.,  89.,  90.,  89.,  90.,  91.,  92.,
      101., 102., 103., 104., 103., 104., 105., 106., 105., 106., 107., 108.,
      109., 110., 111., 112., 113., 114., 115., 116., 117., 118., 119., 120.,
      119., 120., 121., 122., 121., 122., 123., 124., 117., 118., 119., 120.,
      119., 120., 121., 122., 121., 122., 123., 124., 125., 126., 127., 128.,
      129., 130., 131., 132., 133., 134., 135., 136., 135., 136., 137., 138.,
      137., 138., 139., 140., 133., 134., 135., 136., 135., 136., 137., 138.,
      137., 138., 139., 140., 141., 142., 143., 144., 145., 146., 147., 148.,
      149., 150., 151., 152., 151., 152., 153., 154., 153., 154., 155., 156.,
      229., 230., 231., 232., 231., 232., 233., 234., 233., 234., 235., 236.,
      237., 238., 239., 240., 241., 242., 243., 244., 245., 246., 247., 248.,
      247., 248., 249., 250., 249., 250., 251., 252., 245., 246., 247., 248.,
      247., 248., 249., 250., 249., 250., 251., 252., 253., 254., 255., 256.,
      257., 258., 259., 260., 261., 262., 263., 264., 263., 264., 265., 266.,
      265., 266., 267., 268., 261., 262., 263., 264., 263., 264., 265., 266.,
      265., 266., 267., 268., 269., 270., 271., 272., 273., 274., 275., 276.,
      277., 278., 279., 280., 279., 280., 281., 282., 281., 282., 283., 284.,
      293., 294., 295., 296., 295., 296., 297., 298., 297., 298., 299., 300.,
      301., 302., 303., 304., 305., 306., 307., 308., 309., 310., 311., 312.,
      311., 312., 313., 314., 313., 314., 315., 316., 309., 310., 311., 312.,
      311., 312., 313., 314., 313., 314., 315., 316., 317., 318., 319., 320.,
      321., 322., 323., 324., 325., 326., 327., 328., 327., 328., 329., 330.,
      329., 330., 331., 332., 325., 326., 327., 328., 327., 328., 329., 330.,
      329., 330., 331., 332., 333., 334., 335., 336., 337., 338., 339., 340.,
      341., 342., 343., 344., 343., 344., 345., 346., 345., 346., 347., 348.,
      421., 422., 423., 424., 423., 424., 425., 426., 425., 426., 427., 428.,
      429., 430., 431., 432., 433., 434., 435., 436., 437., 438., 439., 440.,
      439., 440., 441., 442., 441., 442., 443., 444., 437., 438., 439., 440.,
      439., 440., 441., 442., 441., 442., 443., 444., 445., 446., 447., 448.,
      449., 450., 451., 452., 453., 454., 455., 456., 455., 456., 457., 458.,
      457., 458., 459., 460., 453., 454., 455., 456., 455., 456., 457., 458.,
      457., 458., 459., 460., 461., 462., 463., 464., 465., 466., 467., 468.,
      469., 470., 471., 472., 471., 472., 473., 474., 473., 474., 475., 476.,
      485., 486., 487., 488., 487., 488., 489., 490., 489., 490., 491., 492.,
      493., 494., 495., 496., 497., 498., 499., 500., 501., 502., 503., 504.,
      503., 504., 505., 506., 505., 506., 507., 508., 501., 502., 503., 504.,
      503., 504., 505., 506., 505., 506., 507., 508., 509., 510., 511., 512.,
      513., 514., 515., 516., 517., 518., 519., 520., 519., 520., 521., 522.,
      521., 522., 523., 524., 517., 518., 519., 520., 519., 520., 521., 522.,
      521., 522., 523., 524., 525., 526., 527., 528., 529., 530., 531., 532.,
      533., 534., 535., 536., 535., 536., 537., 538., 537., 538., 539., 540.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID3x6x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,
      85.,  86.,  87.,  88.,  105., 106., 107., 108., 109., 110., 111., 112.,
      113., 114., 115., 116., 117., 118., 119., 120., 265., 266., 267., 268.,
      269., 270., 271., 272., 273., 274., 275., 276., 277., 278., 279., 280.,
      297., 298., 299., 300., 301., 302., 303., 304., 305., 306., 307., 308.,
      309., 310., 311., 312., 457., 458., 459., 460., 461., 462., 463., 464.,
      465., 466., 467., 468., 469., 470., 471., 472., 489., 490., 491., 492.,
      493., 494., 495., 496., 497., 498., 499., 500., 501., 502., 503., 504.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME3x7x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8.,    8.5,   9.,    10.,   10.5,  11.,   11.,  11.5,  12.,   13.,  13.5,
      14.,   14.,   14.5,  15.,   16.,   16.5,  17.,  20.,   20.5,  21.,  22.,
      22.5,  23.,   26.,   26.5,  27.,   28.,   28.5, 29.,   29.,   29.5, 30.,
      31.,   31.5,  32.,   32.,   32.5,  33.,   34.,  34.5,  35.,   50.,  50.5,
      51.,   52.,   52.5,  53.,   53.,   53.5,  54.,  55.,   55.5,  56.,  56.,
      56.5,  57.,   58.,   58.5,  59.,   62.,   62.5, 63.,   64.,   64.5, 65.,
      68.,   68.5,  69.,   70.,   70.5,  71.,   71.,  71.5,  72.,   73.,  73.5,
      74.,   74.,   74.5,  75.,   76.,   76.5,  77.,  92.,   92.5,  93.,  94.,
      94.5,  95.,   95.,   95.5,  96.,   97.,   97.5, 98.,   98.,   98.5, 99.,
      100.,  100.5, 101.,  104.,  104.5, 105.,  106., 106.5, 107.,  110., 110.5,
      111.,  112.,  112.5, 113.,  113.,  113.5, 114., 115.,  115.5, 116., 116.,
      116.5, 117.,  118.,  118.5, 119.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID3x7x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {15., 16.,  21.,  22.,  27.,  28.,
                                         57., 58.,  63.,  64.,  69.,  70.,
                                         99., 100., 105., 106., 111., 112.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME3x7x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15.,  16.,  16.,  17.,  17.,  18.,  19.,  20.,  20.,  21.,  21.,  22.,
      21.,  22.,  22.,  23.,  23.,  24.,  25.,  26.,  26.,  27.,  27.,  28.,
      27.,  28.,  28.,  29.,  29.,  30.,  31.,  32.,  32.,  33.,  33.,  34.,
      39.,  40.,  40.,  41.,  41.,  42.,  43.,  44.,  44.,  45.,  45.,  46.,
      51.,  52.,  52.,  53.,  53.,  54.,  55.,  56.,  56.,  57.,  57.,  58.,
      57.,  58.,  58.,  59.,  59.,  60.,  61.,  62.,  62.,  63.,  63.,  64.,
      63.,  64.,  64.,  65.,  65.,  66.,  67.,  68.,  68.,  69.,  69.,  70.,
      99.,  100., 100., 101., 101., 102., 103., 104., 104., 105., 105., 106.,
      105., 106., 106., 107., 107., 108., 109., 110., 110., 111., 111., 112.,
      111., 112., 112., 113., 113., 114., 115., 116., 116., 117., 117., 118.,
      123., 124., 124., 125., 125., 126., 127., 128., 128., 129., 129., 130.,
      135., 136., 136., 137., 137., 138., 139., 140., 140., 141., 141., 142.,
      141., 142., 142., 143., 143., 144., 145., 146., 146., 147., 147., 148.,
      147., 148., 148., 149., 149., 150., 151., 152., 152., 153., 153., 154.,
      183., 184., 184., 185., 185., 186., 187., 188., 188., 189., 189., 190.,
      189., 190., 190., 191., 191., 192., 193., 194., 194., 195., 195., 196.,
      195., 196., 196., 197., 197., 198., 199., 200., 200., 201., 201., 202.,
      207., 208., 208., 209., 209., 210., 211., 212., 212., 213., 213., 214.,
      219., 220., 220., 221., 221., 222., 223., 224., 224., 225., 225., 226.,
      225., 226., 226., 227., 227., 228., 229., 230., 230., 231., 231., 232.,
      231., 232., 232., 233., 233., 234., 235., 236., 236., 237., 237., 238.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID3x7x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29.,  30.,  31.,  32.,  41.,  42.,  43.,  44.,  53.,  54.,  55.,  56.,
      113., 114., 115., 116., 125., 126., 127., 128., 137., 138., 139., 140.,
      197., 198., 199., 200., 209., 210., 211., 212., 221., 222., 223., 224.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME3x7x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29.,  30.,  31.,  32.,  31.,  32.,  33.,  34.,  33.,  34.,  35.,  36.,
      37.,  38.,  39.,  40.,  39.,  40.,  41.,  42.,  41.,  42.,  43.,  44.,
      41.,  42.,  43.,  44.,  43.,  44.,  45.,  46.,  45.,  46.,  47.,  48.,
      49.,  50.,  51.,  52.,  51.,  52.,  53.,  54.,  53.,  54.,  55.,  56.,
      53.,  54.,  55.,  56.,  55.,  56.,  57.,  58.,  57.,  58.,  59.,  60.,
      61.,  62.,  63.,  64.,  63.,  64.,  65.,  66.,  65.,  66.,  67.,  68.,
      77.,  78.,  79.,  80.,  79.,  80.,  81.,  82.,  81.,  82.,  83.,  84.,
      85.,  86.,  87.,  88.,  87.,  88.,  89.,  90.,  89.,  90.,  91.,  92.,
      101., 102., 103., 104., 103., 104., 105., 106., 105., 106., 107., 108.,
      109., 110., 111., 112., 111., 112., 113., 114., 113., 114., 115., 116.,
      113., 114., 115., 116., 115., 116., 117., 118., 117., 118., 119., 120.,
      121., 122., 123., 124., 123., 124., 125., 126., 125., 126., 127., 128.,
      125., 126., 127., 128., 127., 128., 129., 130., 129., 130., 131., 132.,
      133., 134., 135., 136., 135., 136., 137., 138., 137., 138., 139., 140.,
      197., 198., 199., 200., 199., 200., 201., 202., 201., 202., 203., 204.,
      205., 206., 207., 208., 207., 208., 209., 210., 209., 210., 211., 212.,
      209., 210., 211., 212., 211., 212., 213., 214., 213., 214., 215., 216.,
      217., 218., 219., 220., 219., 220., 221., 222., 221., 222., 223., 224.,
      221., 222., 223., 224., 223., 224., 225., 226., 225., 226., 227., 228.,
      229., 230., 231., 232., 231., 232., 233., 234., 233., 234., 235., 236.,
      245., 246., 247., 248., 247., 248., 249., 250., 249., 250., 251., 252.,
      253., 254., 255., 256., 255., 256., 257., 258., 257., 258., 259., 260.,
      269., 270., 271., 272., 271., 272., 273., 274., 273., 274., 275., 276.,
      277., 278., 279., 280., 279., 280., 281., 282., 281., 282., 283., 284.,
      281., 282., 283., 284., 283., 284., 285., 286., 285., 286., 287., 288.,
      289., 290., 291., 292., 291., 292., 293., 294., 293., 294., 295., 296.,
      293., 294., 295., 296., 295., 296., 297., 298., 297., 298., 299., 300.,
      301., 302., 303., 304., 303., 304., 305., 306., 305., 306., 307., 308.,
      365., 366., 367., 368., 367., 368., 369., 370., 369., 370., 371., 372.,
      373., 374., 375., 376., 375., 376., 377., 378., 377., 378., 379., 380.,
      377., 378., 379., 380., 379., 380., 381., 382., 381., 382., 383., 384.,
      385., 386., 387., 388., 387., 388., 389., 390., 389., 390., 391., 392.,
      389., 390., 391., 392., 391., 392., 393., 394., 393., 394., 395., 396.,
      397., 398., 399., 400., 399., 400., 401., 402., 401., 402., 403., 404.,
      413., 414., 415., 416., 415., 416., 417., 418., 417., 418., 419., 420.,
      421., 422., 423., 424., 423., 424., 425., 426., 425., 426., 427., 428.,
      437., 438., 439., 440., 439., 440., 441., 442., 441., 442., 443., 444.,
      445., 446., 447., 448., 447., 448., 449., 450., 449., 450., 451., 452.,
      449., 450., 451., 452., 451., 452., 453., 454., 453., 454., 455., 456.,
      457., 458., 459., 460., 459., 460., 461., 462., 461., 462., 463., 464.,
      461., 462., 463., 464., 463., 464., 465., 466., 465., 466., 467., 468.,
      469., 470., 471., 472., 471., 472., 473., 474., 473., 474., 475., 476.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID3x7x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      57.,  58.,  59.,  60.,  61.,  62.,  63.,  64.,  81.,  82.,  83.,  84.,
      85.,  86.,  87.,  88.,  105., 106., 107., 108., 109., 110., 111., 112.,
      225., 226., 227., 228., 229., 230., 231., 232., 249., 250., 251., 252.,
      253., 254., 255., 256., 273., 274., 275., 276., 277., 278., 279., 280.,
      393., 394., 395., 396., 397., 398., 399., 400., 417., 418., 419., 420.,
      421., 422., 423., 424., 441., 442., 443., 444., 445., 446., 447., 448.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME3x7x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9.,    9.5,   10.,  11.,   12.,   12.5,  13.,   12.5,  13.,   13.5,
      14.5,  15.5,  16.,  16.5,  16.,   16.5,  17.,   18.,   19.,   19.5,
      20.,   23.,   23.5, 24.,   25.,   26.,   26.5,  27.,   30.,   30.5,
      31.,   32.,   33.,  33.5,  34.,   33.5,  34.,   34.5,  35.5,  36.5,
      37.,   37.5,  37.,  37.5,  38.,   39.,   40.,   40.5,  41.,   58.,
      58.5,  59.,   60.,  61.,   61.5,  62.,   61.5,  62.,   62.5,  63.5,
      64.5,  65.,   65.5, 65.,   65.5,  66.,   67.,   68.,   68.5,  69.,
      72.,   72.5,  73.,  74.,   75.,   75.5,  76.,   79.,   79.5,  80.,
      81.,   82.,   82.5, 83.,   82.5,  83.,   83.5,  84.5,  85.5,  86.,
      86.5,  86.,   86.5, 87.,   88.,   89.,   89.5,  90.,   107.,  107.5,
      108.,  109.,  110., 110.5, 111.,  110.5, 111.,  111.5, 112.5, 113.5,
      114.,  114.5, 114., 114.5, 115.,  116.,  117.,  117.5, 118.,  121.,
      121.5, 122.,  123., 124.,  124.5, 125.,  128.,  128.5, 129.,  130.,
      131.,  131.5, 132., 131.5, 132.,  132.5, 133.5, 134.5, 135.,  135.5,
      135.,  135.5, 136., 137.,  138.,  138.5, 139.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID3x7x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17.,  18.,  19.,  24.,  25.,  26.,  31.,  32.,  33.,
      66.,  67.,  68.,  73.,  74.,  75.,  80.,  81.,  82.,
      115., 116., 117., 122., 123., 124., 129., 130., 131.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME3x7x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17.,  18.,  18.,  19.,  19.,  20.,  21.,  22.,  23.,  24.,  24.,  25.,
      25.,  26.,  24.,  25.,  25.,  26.,  26.,  27.,  28.,  29.,  30.,  31.,
      31.,  32.,  32.,  33.,  31.,  32.,  32.,  33.,  33.,  34.,  35.,  36.,
      37.,  38.,  38.,  39.,  39.,  40.,  45.,  46.,  46.,  47.,  47.,  48.,
      49.,  50.,  51.,  52.,  52.,  53.,  53.,  54.,  59.,  60.,  60.,  61.,
      61.,  62.,  63.,  64.,  65.,  66.,  66.,  67.,  67.,  68.,  66.,  67.,
      67.,  68.,  68.,  69.,  70.,  71.,  72.,  73.,  73.,  74.,  74.,  75.,
      73.,  74.,  74.,  75.,  75.,  76.,  77.,  78.,  79.,  80.,  80.,  81.,
      81.,  82.,  115., 116., 116., 117., 117., 118., 119., 120., 121., 122.,
      122., 123., 123., 124., 122., 123., 123., 124., 124., 125., 126., 127.,
      128., 129., 129., 130., 130., 131., 129., 130., 130., 131., 131., 132.,
      133., 134., 135., 136., 136., 137., 137., 138., 143., 144., 144., 145.,
      145., 146., 147., 148., 149., 150., 150., 151., 151., 152., 157., 158.,
      158., 159., 159., 160., 161., 162., 163., 164., 164., 165., 165., 166.,
      164., 165., 165., 166., 166., 167., 168., 169., 170., 171., 171., 172.,
      172., 173., 171., 172., 172., 173., 173., 174., 175., 176., 177., 178.,
      178., 179., 179., 180., 213., 214., 214., 215., 215., 216., 217., 218.,
      219., 220., 220., 221., 221., 222., 220., 221., 221., 222., 222., 223.,
      224., 225., 226., 227., 227., 228., 228., 229., 227., 228., 228., 229.,
      229., 230., 231., 232., 233., 234., 234., 235., 235., 236., 241., 242.,
      242., 243., 243., 244., 245., 246., 247., 248., 248., 249., 249., 250.,
      255., 256., 256., 257., 257., 258., 259., 260., 261., 262., 262., 263.,
      263., 264., 262., 263., 263., 264., 264., 265., 266., 267., 268., 269.,
      269., 270., 270., 271., 269., 270., 270., 271., 271., 272., 273., 274.,
      275., 276., 276., 277., 277., 278.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID3x7x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      33.,  34.,  35.,  36.,  37.,  38.,  47.,  48.,  49.,  50.,  51.,
      52.,  61.,  62.,  63.,  64.,  65.,  66.,  131., 132., 133., 134.,
      135., 136., 145., 146., 147., 148., 149., 150., 159., 160., 161.,
      162., 163., 164., 229., 230., 231., 232., 233., 234., 243., 244.,
      245., 246., 247., 248., 257., 258., 259., 260., 261., 262.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME3x7x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      33.,  34.,  35.,  36.,  35.,  36.,  37.,  38.,  37.,  38.,  39.,  40.,
      41.,  42.,  43.,  44.,  45.,  46.,  47.,  48.,  47.,  48.,  49.,  50.,
      49.,  50.,  51.,  52.,  47.,  48.,  49.,  50.,  49.,  50.,  51.,  52.,
      51.,  52.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,  61.,  62.,
      61.,  62.,  63.,  64.,  63.,  64.,  65.,  66.,  61.,  62.,  63.,  64.,
      63.,  64.,  65.,  66.,  65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,
      73.,  74.,  75.,  76.,  75.,  76.,  77.,  78.,  77.,  78.,  79.,  80.,
      89.,  90.,  91.,  92.,  91.,  92.,  93.,  94.,  93.,  94.,  95.,  96.,
      97.,  98.,  99.,  100., 101., 102., 103., 104., 103., 104., 105., 106.,
      105., 106., 107., 108., 117., 118., 119., 120., 119., 120., 121., 122.,
      121., 122., 123., 124., 125., 126., 127., 128., 129., 130., 131., 132.,
      131., 132., 133., 134., 133., 134., 135., 136., 131., 132., 133., 134.,
      133., 134., 135., 136., 135., 136., 137., 138., 139., 140., 141., 142.,
      143., 144., 145., 146., 145., 146., 147., 148., 147., 148., 149., 150.,
      145., 146., 147., 148., 147., 148., 149., 150., 149., 150., 151., 152.,
      153., 154., 155., 156., 157., 158., 159., 160., 159., 160., 161., 162.,
      161., 162., 163., 164., 229., 230., 231., 232., 231., 232., 233., 234.,
      233., 234., 235., 236., 237., 238., 239., 240., 241., 242., 243., 244.,
      243., 244., 245., 246., 245., 246., 247., 248., 243., 244., 245., 246.,
      245., 246., 247., 248., 247., 248., 249., 250., 251., 252., 253., 254.,
      255., 256., 257., 258., 257., 258., 259., 260., 259., 260., 261., 262.,
      257., 258., 259., 260., 259., 260., 261., 262., 261., 262., 263., 264.,
      265., 266., 267., 268., 269., 270., 271., 272., 271., 272., 273., 274.,
      273., 274., 275., 276., 285., 286., 287., 288., 287., 288., 289., 290.,
      289., 290., 291., 292., 293., 294., 295., 296., 297., 298., 299., 300.,
      299., 300., 301., 302., 301., 302., 303., 304., 313., 314., 315., 316.,
      315., 316., 317., 318., 317., 318., 319., 320., 321., 322., 323., 324.,
      325., 326., 327., 328., 327., 328., 329., 330., 329., 330., 331., 332.,
      327., 328., 329., 330., 329., 330., 331., 332., 331., 332., 333., 334.,
      335., 336., 337., 338., 339., 340., 341., 342., 341., 342., 343., 344.,
      343., 344., 345., 346., 341., 342., 343., 344., 343., 344., 345., 346.,
      345., 346., 347., 348., 349., 350., 351., 352., 353., 354., 355., 356.,
      355., 356., 357., 358., 357., 358., 359., 360., 425., 426., 427., 428.,
      427., 428., 429., 430., 429., 430., 431., 432., 433., 434., 435., 436.,
      437., 438., 439., 440., 439., 440., 441., 442., 441., 442., 443., 444.,
      439., 440., 441., 442., 441., 442., 443., 444., 443., 444., 445., 446.,
      447., 448., 449., 450., 451., 452., 453., 454., 453., 454., 455., 456.,
      455., 456., 457., 458., 453., 454., 455., 456., 455., 456., 457., 458.,
      457., 458., 459., 460., 461., 462., 463., 464., 465., 466., 467., 468.,
      467., 468., 469., 470., 469., 470., 471., 472., 481., 482., 483., 484.,
      483., 484., 485., 486., 485., 486., 487., 488., 489., 490., 491., 492.,
      493., 494., 495., 496., 495., 496., 497., 498., 497., 498., 499., 500.,
      509., 510., 511., 512., 511., 512., 513., 514., 513., 514., 515., 516.,
      517., 518., 519., 520., 521., 522., 523., 524., 523., 524., 525., 526.,
      525., 526., 527., 528., 523., 524., 525., 526., 525., 526., 527., 528.,
      527., 528., 529., 530., 531., 532., 533., 534., 535., 536., 537., 538.,
      537., 538., 539., 540., 539., 540., 541., 542., 537., 538., 539., 540.,
      539., 540., 541., 542., 541., 542., 543., 544., 545., 546., 547., 548.,
      549., 550., 551., 552., 551., 552., 553., 554., 553., 554., 555., 556.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID3x7x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,  73.,  74.,  75.,  76.,
      93.,  94.,  95.,  96.,  97.,  98.,  99.,  100., 101., 102., 103., 104.,
      121., 122., 123., 124., 125., 126., 127., 128., 129., 130., 131., 132.,
      261., 262., 263., 264., 265., 266., 267., 268., 269., 270., 271., 272.,
      289., 290., 291., 292., 293., 294., 295., 296., 297., 298., 299., 300.,
      317., 318., 319., 320., 321., 322., 323., 324., 325., 326., 327., 328.,
      457., 458., 459., 460., 461., 462., 463., 464., 465., 466., 467., 468.,
      485., 486., 487., 488., 489., 490., 491., 492., 493., 494., 495., 496.,
      513., 514., 515., 516., 517., 518., 519., 520., 521., 522., 523., 524.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME3x7x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10.,   10.5,  11.,   12.,   13.,   14.,   14.5, 15.,   14.,   14.5, 15.,
      16.,   17.,   18.,   18.5,  19.,   18.,   18.5, 19.,   20.,   21.,  22.,
      22.5,  23.,   26.,   26.5,  27.,   28.,   29.,  30.,   30.5,  31.,  34.,
      34.5,  35.,   36.,   37.,   38.,   38.5,  39.,  38.,   38.5,  39.,  40.,
      41.,   42.,   42.5,  43.,   42.,   42.5,  43.,  44.,   45.,   46.,  46.5,
      47.,   66.,   66.5,  67.,   68.,   69.,   70.,  70.5,  71.,   70.,  70.5,
      71.,   72.,   73.,   74.,   74.5,  75.,   74.,  74.5,  75.,   76.,  77.,
      78.,   78.5,  79.,   82.,   82.5,  83.,   84.,  85.,   86.,   86.5, 87.,
      90.,   90.5,  91.,   92.,   93.,   94.,   94.5, 95.,   94.,   94.5, 95.,
      96.,   97.,   98.,   98.5,  99.,   98.,   98.5, 99.,   100.,  101., 102.,
      102.5, 103.,  122.,  122.5, 123.,  124.,  125., 126.,  126.5, 127., 126.,
      126.5, 127.,  128.,  129.,  130.,  130.5, 131., 130.,  130.5, 131., 132.,
      133.,  134.,  134.5, 135.,  138.,  138.5, 139., 140.,  141.,  142., 142.5,
      143.,  146.,  146.5, 147.,  148.,  149.,  150., 150.5, 151.,  150., 150.5,
      151.,  152.,  153.,  154.,  154.5, 155.,  154., 154.5, 155.,  156., 157.,
      158.,  158.5, 159.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID3x7x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19.,  20.,  21.,  22.,  27.,  28.,  29.,  30.,  35.,  36.,  37.,  38.,
      75.,  76.,  77.,  78.,  83.,  84.,  85.,  86.,  91.,  92.,  93.,  94.,
      131., 132., 133., 134., 139., 140., 141., 142., 147., 148., 149., 150.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME3x7x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19.,  20.,  20.,  21.,  21.,  22.,  23.,  24.,  25.,  26.,  27.,  28.,
      28.,  29.,  29.,  30.,  27.,  28.,  28.,  29.,  29.,  30.,  31.,  32.,
      33.,  34.,  35.,  36.,  36.,  37.,  37.,  38.,  35.,  36.,  36.,  37.,
      37.,  38.,  39.,  40.,  41.,  42.,  43.,  44.,  44.,  45.,  45.,  46.,
      51.,  52.,  52.,  53.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,
      60.,  61.,  61.,  62.,  67.,  68.,  68.,  69.,  69.,  70.,  71.,  72.,
      73.,  74.,  75.,  76.,  76.,  77.,  77.,  78.,  75.,  76.,  76.,  77.,
      77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,  84.,  85.,  85.,  86.,
      83.,  84.,  84.,  85.,  85.,  86.,  87.,  88.,  89.,  90.,  91.,  92.,
      92.,  93.,  93.,  94.,  131., 132., 132., 133., 133., 134., 135., 136.,
      137., 138., 139., 140., 140., 141., 141., 142., 139., 140., 140., 141.,
      141., 142., 143., 144., 145., 146., 147., 148., 148., 149., 149., 150.,
      147., 148., 148., 149., 149., 150., 151., 152., 153., 154., 155., 156.,
      156., 157., 157., 158., 163., 164., 164., 165., 165., 166., 167., 168.,
      169., 170., 171., 172., 172., 173., 173., 174., 179., 180., 180., 181.,
      181., 182., 183., 184., 185., 186., 187., 188., 188., 189., 189., 190.,
      187., 188., 188., 189., 189., 190., 191., 192., 193., 194., 195., 196.,
      196., 197., 197., 198., 195., 196., 196., 197., 197., 198., 199., 200.,
      201., 202., 203., 204., 204., 205., 205., 206., 243., 244., 244., 245.,
      245., 246., 247., 248., 249., 250., 251., 252., 252., 253., 253., 254.,
      251., 252., 252., 253., 253., 254., 255., 256., 257., 258., 259., 260.,
      260., 261., 261., 262., 259., 260., 260., 261., 261., 262., 263., 264.,
      265., 266., 267., 268., 268., 269., 269., 270., 275., 276., 276., 277.,
      277., 278., 279., 280., 281., 282., 283., 284., 284., 285., 285., 286.,
      291., 292., 292., 293., 293., 294., 295., 296., 297., 298., 299., 300.,
      300., 301., 301., 302., 299., 300., 300., 301., 301., 302., 303., 304.,
      305., 306., 307., 308., 308., 309., 309., 310., 307., 308., 308., 309.,
      309., 310., 311., 312., 313., 314., 315., 316., 316., 317., 317., 318.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID3x7x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      37.,  38.,  39.,  40.,  41.,  42.,  43.,  44.,  53.,  54.,  55.,  56.,
      57.,  58.,  59.,  60.,  69.,  70.,  71.,  72.,  73.,  74.,  75.,  76.,
      149., 150., 151., 152., 153., 154., 155., 156., 165., 166., 167., 168.,
      169., 170., 171., 172., 181., 182., 183., 184., 185., 186., 187., 188.,
      261., 262., 263., 264., 265., 266., 267., 268., 277., 278., 279., 280.,
      281., 282., 283., 284., 293., 294., 295., 296., 297., 298., 299., 300.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME3x7x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      37.,  38.,  39.,  40.,  39.,  40.,  41.,  42.,  41.,  42.,  43.,  44.,
      45.,  46.,  47.,  48.,  49.,  50.,  51.,  52.,  53.,  54.,  55.,  56.,
      55.,  56.,  57.,  58.,  57.,  58.,  59.,  60.,  53.,  54.,  55.,  56.,
      55.,  56.,  57.,  58.,  57.,  58.,  59.,  60.,  61.,  62.,  63.,  64.,
      65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,  71.,  72.,  73.,  74.,
      73.,  74.,  75.,  76.,  69.,  70.,  71.,  72.,  71.,  72.,  73.,  74.,
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,
      85.,  86.,  87.,  88.,  87.,  88.,  89.,  90.,  89.,  90.,  91.,  92.,
      101., 102., 103., 104., 103., 104., 105., 106., 105., 106., 107., 108.,
      109., 110., 111., 112., 113., 114., 115., 116., 117., 118., 119., 120.,
      119., 120., 121., 122., 121., 122., 123., 124., 133., 134., 135., 136.,
      135., 136., 137., 138., 137., 138., 139., 140., 141., 142., 143., 144.,
      145., 146., 147., 148., 149., 150., 151., 152., 151., 152., 153., 154.,
      153., 154., 155., 156., 149., 150., 151., 152., 151., 152., 153., 154.,
      153., 154., 155., 156., 157., 158., 159., 160., 161., 162., 163., 164.,
      165., 166., 167., 168., 167., 168., 169., 170., 169., 170., 171., 172.,
      165., 166., 167., 168., 167., 168., 169., 170., 169., 170., 171., 172.,
      173., 174., 175., 176., 177., 178., 179., 180., 181., 182., 183., 184.,
      183., 184., 185., 186., 185., 186., 187., 188., 261., 262., 263., 264.,
      263., 264., 265., 266., 265., 266., 267., 268., 269., 270., 271., 272.,
      273., 274., 275., 276., 277., 278., 279., 280., 279., 280., 281., 282.,
      281., 282., 283., 284., 277., 278., 279., 280., 279., 280., 281., 282.,
      281., 282., 283., 284., 285., 286., 287., 288., 289., 290., 291., 292.,
      293., 294., 295., 296., 295., 296., 297., 298., 297., 298., 299., 300.,
      293., 294., 295., 296., 295., 296., 297., 298., 297., 298., 299., 300.,
      301., 302., 303., 304., 305., 306., 307., 308., 309., 310., 311., 312.,
      311., 312., 313., 314., 313., 314., 315., 316., 325., 326., 327., 328.,
      327., 328., 329., 330., 329., 330., 331., 332., 333., 334., 335., 336.,
      337., 338., 339., 340., 341., 342., 343., 344., 343., 344., 345., 346.,
      345., 346., 347., 348., 357., 358., 359., 360., 359., 360., 361., 362.,
      361., 362., 363., 364., 365., 366., 367., 368., 369., 370., 371., 372.,
      373., 374., 375., 376., 375., 376., 377., 378., 377., 378., 379., 380.,
      373., 374., 375., 376., 375., 376., 377., 378., 377., 378., 379., 380.,
      381., 382., 383., 384., 385., 386., 387., 388., 389., 390., 391., 392.,
      391., 392., 393., 394., 393., 394., 395., 396., 389., 390., 391., 392.,
      391., 392., 393., 394., 393., 394., 395., 396., 397., 398., 399., 400.,
      401., 402., 403., 404., 405., 406., 407., 408., 407., 408., 409., 410.,
      409., 410., 411., 412., 485., 486., 487., 488., 487., 488., 489., 490.,
      489., 490., 491., 492., 493., 494., 495., 496., 497., 498., 499., 500.,
      501., 502., 503., 504., 503., 504., 505., 506., 505., 506., 507., 508.,
      501., 502., 503., 504., 503., 504., 505., 506., 505., 506., 507., 508.,
      509., 510., 511., 512., 513., 514., 515., 516., 517., 518., 519., 520.,
      519., 520., 521., 522., 521., 522., 523., 524., 517., 518., 519., 520.,
      519., 520., 521., 522., 521., 522., 523., 524., 525., 526., 527., 528.,
      529., 530., 531., 532., 533., 534., 535., 536., 535., 536., 537., 538.,
      537., 538., 539., 540., 549., 550., 551., 552., 551., 552., 553., 554.,
      553., 554., 555., 556., 557., 558., 559., 560., 561., 562., 563., 564.,
      565., 566., 567., 568., 567., 568., 569., 570., 569., 570., 571., 572.,
      581., 582., 583., 584., 583., 584., 585., 586., 585., 586., 587., 588.,
      589., 590., 591., 592., 593., 594., 595., 596., 597., 598., 599., 600.,
      599., 600., 601., 602., 601., 602., 603., 604., 597., 598., 599., 600.,
      599., 600., 601., 602., 601., 602., 603., 604., 605., 606., 607., 608.,
      609., 610., 611., 612., 613., 614., 615., 616., 615., 616., 617., 618.,
      617., 618., 619., 620., 613., 614., 615., 616., 615., 616., 617., 618.,
      617., 618., 619., 620., 621., 622., 623., 624., 625., 626., 627., 628.,
      629., 630., 631., 632., 631., 632., 633., 634., 633., 634., 635., 636.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID3x7x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,
      85.,  86.,  87.,  88.,  105., 106., 107., 108., 109., 110., 111., 112.,
      113., 114., 115., 116., 117., 118., 119., 120., 137., 138., 139., 140.,
      141., 142., 143., 144., 145., 146., 147., 148., 149., 150., 151., 152.,
      297., 298., 299., 300., 301., 302., 303., 304., 305., 306., 307., 308.,
      309., 310., 311., 312., 329., 330., 331., 332., 333., 334., 335., 336.,
      337., 338., 339., 340., 341., 342., 343., 344., 361., 362., 363., 364.,
      365., 366., 367., 368., 369., 370., 371., 372., 373., 374., 375., 376.,
      521., 522., 523., 524., 525., 526., 527., 528., 529., 530., 531., 532.,
      533., 534., 535., 536., 553., 554., 555., 556., 557., 558., 559., 560.,
      561., 562., 563., 564., 565., 566., 567., 568., 585., 586., 587., 588.,
      589., 590., 591., 592., 593., 594., 595., 596., 597., 598., 599., 600.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME3x8x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8.,    8.5,   9.,    10.,   10.5,  11.,   11.,   11.5,  12.,   13.,
      13.5,  14.,   14.,   14.5,  15.,   16.,   16.5,  17.,   20.,   20.5,
      21.,   22.,   22.5,  23.,   26.,   26.5,  27.,   28.,   28.5,  29.,
      32.,   32.5,  33.,   34.,   34.5,  35.,   35.,   35.5,  36.,   37.,
      37.5,  38.,   38.,   38.5,  39.,   40.,   40.5,  41.,   56.,   56.5,
      57.,   58.,   58.5,  59.,   59.,   59.5,  60.,   61.,   61.5,  62.,
      62.,   62.5,  63.,   64.,   64.5,  65.,   68.,   68.5,  69.,   70.,
      70.5,  71.,   74.,   74.5,  75.,   76.,   76.5,  77.,   80.,   80.5,
      81.,   82.,   82.5,  83.,   83.,   83.5,  84.,   85.,   85.5,  86.,
      86.,   86.5,  87.,   88.,   88.5,  89.,   104.,  104.5, 105.,  106.,
      106.5, 107.,  107.,  107.5, 108.,  109.,  109.5, 110.,  110.,  110.5,
      111.,  112.,  112.5, 113.,  116.,  116.5, 117.,  118.,  118.5, 119.,
      122.,  122.5, 123.,  124.,  124.5, 125.,  128.,  128.5, 129.,  130.,
      130.5, 131.,  131.,  131.5, 132.,  133.,  133.5, 134.,  134.,  134.5,
      135.,  136.,  136.5, 137.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID3x8x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15., 16., 21., 22., 27.,  28.,  33.,  34.,  63.,  64.,  69.,  70.,
      75., 76., 81., 82., 111., 112., 117., 118., 123., 124., 129., 130.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME3x8x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15.,  16.,  16.,  17.,  17.,  18.,  19.,  20.,  20.,  21.,  21.,  22.,
      21.,  22.,  22.,  23.,  23.,  24.,  25.,  26.,  26.,  27.,  27.,  28.,
      27.,  28.,  28.,  29.,  29.,  30.,  31.,  32.,  32.,  33.,  33.,  34.,
      39.,  40.,  40.,  41.,  41.,  42.,  43.,  44.,  44.,  45.,  45.,  46.,
      51.,  52.,  52.,  53.,  53.,  54.,  55.,  56.,  56.,  57.,  57.,  58.,
      63.,  64.,  64.,  65.,  65.,  66.,  67.,  68.,  68.,  69.,  69.,  70.,
      69.,  70.,  70.,  71.,  71.,  72.,  73.,  74.,  74.,  75.,  75.,  76.,
      75.,  76.,  76.,  77.,  77.,  78.,  79.,  80.,  80.,  81.,  81.,  82.,
      111., 112., 112., 113., 113., 114., 115., 116., 116., 117., 117., 118.,
      117., 118., 118., 119., 119., 120., 121., 122., 122., 123., 123., 124.,
      123., 124., 124., 125., 125., 126., 127., 128., 128., 129., 129., 130.,
      135., 136., 136., 137., 137., 138., 139., 140., 140., 141., 141., 142.,
      147., 148., 148., 149., 149., 150., 151., 152., 152., 153., 153., 154.,
      159., 160., 160., 161., 161., 162., 163., 164., 164., 165., 165., 166.,
      165., 166., 166., 167., 167., 168., 169., 170., 170., 171., 171., 172.,
      171., 172., 172., 173., 173., 174., 175., 176., 176., 177., 177., 178.,
      207., 208., 208., 209., 209., 210., 211., 212., 212., 213., 213., 214.,
      213., 214., 214., 215., 215., 216., 217., 218., 218., 219., 219., 220.,
      219., 220., 220., 221., 221., 222., 223., 224., 224., 225., 225., 226.,
      231., 232., 232., 233., 233., 234., 235., 236., 236., 237., 237., 238.,
      243., 244., 244., 245., 245., 246., 247., 248., 248., 249., 249., 250.,
      255., 256., 256., 257., 257., 258., 259., 260., 260., 261., 261., 262.,
      261., 262., 262., 263., 263., 264., 265., 266., 266., 267., 267., 268.,
      267., 268., 268., 269., 269., 270., 271., 272., 272., 273., 273., 274.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID3x8x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29.,  30.,  31.,  32.,  41.,  42.,  43.,  44.,  53.,  54.,  55.,  56.,
      65.,  66.,  67.,  68.,  125., 126., 127., 128., 137., 138., 139., 140.,
      149., 150., 151., 152., 161., 162., 163., 164., 221., 222., 223., 224.,
      233., 234., 235., 236., 245., 246., 247., 248., 257., 258., 259., 260.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME3x8x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29.,  30.,  31.,  32.,  31.,  32.,  33.,  34.,  33.,  34.,  35.,  36.,
      37.,  38.,  39.,  40.,  39.,  40.,  41.,  42.,  41.,  42.,  43.,  44.,
      41.,  42.,  43.,  44.,  43.,  44.,  45.,  46.,  45.,  46.,  47.,  48.,
      49.,  50.,  51.,  52.,  51.,  52.,  53.,  54.,  53.,  54.,  55.,  56.,
      53.,  54.,  55.,  56.,  55.,  56.,  57.,  58.,  57.,  58.,  59.,  60.,
      61.,  62.,  63.,  64.,  63.,  64.,  65.,  66.,  65.,  66.,  67.,  68.,
      77.,  78.,  79.,  80.,  79.,  80.,  81.,  82.,  81.,  82.,  83.,  84.,
      85.,  86.,  87.,  88.,  87.,  88.,  89.,  90.,  89.,  90.,  91.,  92.,
      101., 102., 103., 104., 103., 104., 105., 106., 105., 106., 107., 108.,
      109., 110., 111., 112., 111., 112., 113., 114., 113., 114., 115., 116.,
      125., 126., 127., 128., 127., 128., 129., 130., 129., 130., 131., 132.,
      133., 134., 135., 136., 135., 136., 137., 138., 137., 138., 139., 140.,
      137., 138., 139., 140., 139., 140., 141., 142., 141., 142., 143., 144.,
      145., 146., 147., 148., 147., 148., 149., 150., 149., 150., 151., 152.,
      149., 150., 151., 152., 151., 152., 153., 154., 153., 154., 155., 156.,
      157., 158., 159., 160., 159., 160., 161., 162., 161., 162., 163., 164.,
      221., 222., 223., 224., 223., 224., 225., 226., 225., 226., 227., 228.,
      229., 230., 231., 232., 231., 232., 233., 234., 233., 234., 235., 236.,
      233., 234., 235., 236., 235., 236., 237., 238., 237., 238., 239., 240.,
      241., 242., 243., 244., 243., 244., 245., 246., 245., 246., 247., 248.,
      245., 246., 247., 248., 247., 248., 249., 250., 249., 250., 251., 252.,
      253., 254., 255., 256., 255., 256., 257., 258., 257., 258., 259., 260.,
      269., 270., 271., 272., 271., 272., 273., 274., 273., 274., 275., 276.,
      277., 278., 279., 280., 279., 280., 281., 282., 281., 282., 283., 284.,
      293., 294., 295., 296., 295., 296., 297., 298., 297., 298., 299., 300.,
      301., 302., 303., 304., 303., 304., 305., 306., 305., 306., 307., 308.,
      317., 318., 319., 320., 319., 320., 321., 322., 321., 322., 323., 324.,
      325., 326., 327., 328., 327., 328., 329., 330., 329., 330., 331., 332.,
      329., 330., 331., 332., 331., 332., 333., 334., 333., 334., 335., 336.,
      337., 338., 339., 340., 339., 340., 341., 342., 341., 342., 343., 344.,
      341., 342., 343., 344., 343., 344., 345., 346., 345., 346., 347., 348.,
      349., 350., 351., 352., 351., 352., 353., 354., 353., 354., 355., 356.,
      413., 414., 415., 416., 415., 416., 417., 418., 417., 418., 419., 420.,
      421., 422., 423., 424., 423., 424., 425., 426., 425., 426., 427., 428.,
      425., 426., 427., 428., 427., 428., 429., 430., 429., 430., 431., 432.,
      433., 434., 435., 436., 435., 436., 437., 438., 437., 438., 439., 440.,
      437., 438., 439., 440., 439., 440., 441., 442., 441., 442., 443., 444.,
      445., 446., 447., 448., 447., 448., 449., 450., 449., 450., 451., 452.,
      461., 462., 463., 464., 463., 464., 465., 466., 465., 466., 467., 468.,
      469., 470., 471., 472., 471., 472., 473., 474., 473., 474., 475., 476.,
      485., 486., 487., 488., 487., 488., 489., 490., 489., 490., 491., 492.,
      493., 494., 495., 496., 495., 496., 497., 498., 497., 498., 499., 500.,
      509., 510., 511., 512., 511., 512., 513., 514., 513., 514., 515., 516.,
      517., 518., 519., 520., 519., 520., 521., 522., 521., 522., 523., 524.,
      521., 522., 523., 524., 523., 524., 525., 526., 525., 526., 527., 528.,
      529., 530., 531., 532., 531., 532., 533., 534., 533., 534., 535., 536.,
      533., 534., 535., 536., 535., 536., 537., 538., 537., 538., 539., 540.,
      541., 542., 543., 544., 543., 544., 545., 546., 545., 546., 547., 548.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID3x8x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      57.,  58.,  59.,  60.,  61.,  62.,  63.,  64.,  81.,  82.,  83.,  84.,
      85.,  86.,  87.,  88.,  105., 106., 107., 108., 109., 110., 111., 112.,
      129., 130., 131., 132., 133., 134., 135., 136., 249., 250., 251., 252.,
      253., 254., 255., 256., 273., 274., 275., 276., 277., 278., 279., 280.,
      297., 298., 299., 300., 301., 302., 303., 304., 321., 322., 323., 324.,
      325., 326., 327., 328., 441., 442., 443., 444., 445., 446., 447., 448.,
      465., 466., 467., 468., 469., 470., 471., 472., 489., 490., 491., 492.,
      493., 494., 495., 496., 513., 514., 515., 516., 517., 518., 519., 520.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME3x8x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9.,    9.5,   10.,   11.,   12.,   12.5,  13.,   12.5,  13.,   13.5,
      14.5,  15.5,  16.,   16.5,  16.,   16.5,  17.,   18.,   19.,   19.5,
      20.,   23.,   23.5,  24.,   25.,   26.,   26.5,  27.,   30.,   30.5,
      31.,   32.,   33.,   33.5,  34.,   37.,   37.5,  38.,   39.,   40.,
      40.5,  41.,   40.5,  41.,   41.5,  42.5,  43.5,  44.,   44.5,  44.,
      44.5,  45.,   46.,   47.,   47.5,  48.,   65.,   65.5,  66.,   67.,
      68.,   68.5,  69.,   68.5,  69.,   69.5,  70.5,  71.5,  72.,   72.5,
      72.,   72.5,  73.,   74.,   75.,   75.5,  76.,   79.,   79.5,  80.,
      81.,   82.,   82.5,  83.,   86.,   86.5,  87.,   88.,   89.,   89.5,
      90.,   93.,   93.5,  94.,   95.,   96.,   96.5,  97.,   96.5,  97.,
      97.5,  98.5,  99.5,  100.,  100.5, 100.,  100.5, 101.,  102.,  103.,
      103.5, 104.,  121.,  121.5, 122.,  123.,  124.,  124.5, 125.,  124.5,
      125.,  125.5, 126.5, 127.5, 128.,  128.5, 128.,  128.5, 129.,  130.,
      131.,  131.5, 132.,  135.,  135.5, 136.,  137.,  138.,  138.5, 139.,
      142.,  142.5, 143.,  144.,  145.,  145.5, 146.,  149.,  149.5, 150.,
      151.,  152.,  152.5, 153.,  152.5, 153.,  153.5, 154.5, 155.5, 156.,
      156.5, 156.,  156.5, 157.,  158.,  159.,  159.5, 160.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID3x8x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17.,  18.,  19.,  24.,  25.,  26.,  31.,  32.,  33.,  38.,  39.,  40.,
      73.,  74.,  75.,  80.,  81.,  82.,  87.,  88.,  89.,  94.,  95.,  96.,
      129., 130., 131., 136., 137., 138., 143., 144., 145., 150., 151., 152.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME3x8x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17.,  18.,  18.,  19.,  19.,  20.,  21.,  22.,  23.,  24.,  24.,  25.,
      25.,  26.,  24.,  25.,  25.,  26.,  26.,  27.,  28.,  29.,  30.,  31.,
      31.,  32.,  32.,  33.,  31.,  32.,  32.,  33.,  33.,  34.,  35.,  36.,
      37.,  38.,  38.,  39.,  39.,  40.,  45.,  46.,  46.,  47.,  47.,  48.,
      49.,  50.,  51.,  52.,  52.,  53.,  53.,  54.,  59.,  60.,  60.,  61.,
      61.,  62.,  63.,  64.,  65.,  66.,  66.,  67.,  67.,  68.,  73.,  74.,
      74.,  75.,  75.,  76.,  77.,  78.,  79.,  80.,  80.,  81.,  81.,  82.,
      80.,  81.,  81.,  82.,  82.,  83.,  84.,  85.,  86.,  87.,  87.,  88.,
      88.,  89.,  87.,  88.,  88.,  89.,  89.,  90.,  91.,  92.,  93.,  94.,
      94.,  95.,  95.,  96.,  129., 130., 130., 131., 131., 132., 133., 134.,
      135., 136., 136., 137., 137., 138., 136., 137., 137., 138., 138., 139.,
      140., 141., 142., 143., 143., 144., 144., 145., 143., 144., 144., 145.,
      145., 146., 147., 148., 149., 150., 150., 151., 151., 152., 157., 158.,
      158., 159., 159., 160., 161., 162., 163., 164., 164., 165., 165., 166.,
      171., 172., 172., 173., 173., 174., 175., 176., 177., 178., 178., 179.,
      179., 180., 185., 186., 186., 187., 187., 188., 189., 190., 191., 192.,
      192., 193., 193., 194., 192., 193., 193., 194., 194., 195., 196., 197.,
      198., 199., 199., 200., 200., 201., 199., 200., 200., 201., 201., 202.,
      203., 204., 205., 206., 206., 207., 207., 208., 241., 242., 242., 243.,
      243., 244., 245., 246., 247., 248., 248., 249., 249., 250., 248., 249.,
      249., 250., 250., 251., 252., 253., 254., 255., 255., 256., 256., 257.,
      255., 256., 256., 257., 257., 258., 259., 260., 261., 262., 262., 263.,
      263., 264., 269., 270., 270., 271., 271., 272., 273., 274., 275., 276.,
      276., 277., 277., 278., 283., 284., 284., 285., 285., 286., 287., 288.,
      289., 290., 290., 291., 291., 292., 297., 298., 298., 299., 299., 300.,
      301., 302., 303., 304., 304., 305., 305., 306., 304., 305., 305., 306.,
      306., 307., 308., 309., 310., 311., 311., 312., 312., 313., 311., 312.,
      312., 313., 313., 314., 315., 316., 317., 318., 318., 319., 319., 320.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID3x8x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      33.,  34.,  35.,  36.,  37.,  38.,  47.,  48.,  49.,  50.,  51.,  52.,
      61.,  62.,  63.,  64.,  65.,  66.,  75.,  76.,  77.,  78.,  79.,  80.,
      145., 146., 147., 148., 149., 150., 159., 160., 161., 162., 163., 164.,
      173., 174., 175., 176., 177., 178., 187., 188., 189., 190., 191., 192.,
      257., 258., 259., 260., 261., 262., 271., 272., 273., 274., 275., 276.,
      285., 286., 287., 288., 289., 290., 299., 300., 301., 302., 303., 304.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME3x8x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      33.,  34.,  35.,  36.,  35.,  36.,  37.,  38.,  37.,  38.,  39.,  40.,
      41.,  42.,  43.,  44.,  45.,  46.,  47.,  48.,  47.,  48.,  49.,  50.,
      49.,  50.,  51.,  52.,  47.,  48.,  49.,  50.,  49.,  50.,  51.,  52.,
      51.,  52.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,  61.,  62.,
      61.,  62.,  63.,  64.,  63.,  64.,  65.,  66.,  61.,  62.,  63.,  64.,
      63.,  64.,  65.,  66.,  65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,
      73.,  74.,  75.,  76.,  75.,  76.,  77.,  78.,  77.,  78.,  79.,  80.,
      89.,  90.,  91.,  92.,  91.,  92.,  93.,  94.,  93.,  94.,  95.,  96.,
      97.,  98.,  99.,  100., 101., 102., 103., 104., 103., 104., 105., 106.,
      105., 106., 107., 108., 117., 118., 119., 120., 119., 120., 121., 122.,
      121., 122., 123., 124., 125., 126., 127., 128., 129., 130., 131., 132.,
      131., 132., 133., 134., 133., 134., 135., 136., 145., 146., 147., 148.,
      147., 148., 149., 150., 149., 150., 151., 152., 153., 154., 155., 156.,
      157., 158., 159., 160., 159., 160., 161., 162., 161., 162., 163., 164.,
      159., 160., 161., 162., 161., 162., 163., 164., 163., 164., 165., 166.,
      167., 168., 169., 170., 171., 172., 173., 174., 173., 174., 175., 176.,
      175., 176., 177., 178., 173., 174., 175., 176., 175., 176., 177., 178.,
      177., 178., 179., 180., 181., 182., 183., 184., 185., 186., 187., 188.,
      187., 188., 189., 190., 189., 190., 191., 192., 257., 258., 259., 260.,
      259., 260., 261., 262., 261., 262., 263., 264., 265., 266., 267., 268.,
      269., 270., 271., 272., 271., 272., 273., 274., 273., 274., 275., 276.,
      271., 272., 273., 274., 273., 274., 275., 276., 275., 276., 277., 278.,
      279., 280., 281., 282., 283., 284., 285., 286., 285., 286., 287., 288.,
      287., 288., 289., 290., 285., 286., 287., 288., 287., 288., 289., 290.,
      289., 290., 291., 292., 293., 294., 295., 296., 297., 298., 299., 300.,
      299., 300., 301., 302., 301., 302., 303., 304., 313., 314., 315., 316.,
      315., 316., 317., 318., 317., 318., 319., 320., 321., 322., 323., 324.,
      325., 326., 327., 328., 327., 328., 329., 330., 329., 330., 331., 332.,
      341., 342., 343., 344., 343., 344., 345., 346., 345., 346., 347., 348.,
      349., 350., 351., 352., 353., 354., 355., 356., 355., 356., 357., 358.,
      357., 358., 359., 360., 369., 370., 371., 372., 371., 372., 373., 374.,
      373., 374., 375., 376., 377., 378., 379., 380., 381., 382., 383., 384.,
      383., 384., 385., 386., 385., 386., 387., 388., 383., 384., 385., 386.,
      385., 386., 387., 388., 387., 388., 389., 390., 391., 392., 393., 394.,
      395., 396., 397., 398., 397., 398., 399., 400., 399., 400., 401., 402.,
      397., 398., 399., 400., 399., 400., 401., 402., 401., 402., 403., 404.,
      405., 406., 407., 408., 409., 410., 411., 412., 411., 412., 413., 414.,
      413., 414., 415., 416., 481., 482., 483., 484., 483., 484., 485., 486.,
      485., 486., 487., 488., 489., 490., 491., 492., 493., 494., 495., 496.,
      495., 496., 497., 498., 497., 498., 499., 500., 495., 496., 497., 498.,
      497., 498., 499., 500., 499., 500., 501., 502., 503., 504., 505., 506.,
      507., 508., 509., 510., 509., 510., 511., 512., 511., 512., 513., 514.,
      509., 510., 511., 512., 511., 512., 513., 514., 513., 514., 515., 516.,
      517., 518., 519., 520., 521., 522., 523., 524., 523., 524., 525., 526.,
      525., 526., 527., 528., 537., 538., 539., 540., 539., 540., 541., 542.,
      541., 542., 543., 544., 545., 546., 547., 548., 549., 550., 551., 552.,
      551., 552., 553., 554., 553., 554., 555., 556., 565., 566., 567., 568.,
      567., 568., 569., 570., 569., 570., 571., 572., 573., 574., 575., 576.,
      577., 578., 579., 580., 579., 580., 581., 582., 581., 582., 583., 584.,
      593., 594., 595., 596., 595., 596., 597., 598., 597., 598., 599., 600.,
      601., 602., 603., 604., 605., 606., 607., 608., 607., 608., 609., 610.,
      609., 610., 611., 612., 607., 608., 609., 610., 609., 610., 611., 612.,
      611., 612., 613., 614., 615., 616., 617., 618., 619., 620., 621., 622.,
      621., 622., 623., 624., 623., 624., 625., 626., 621., 622., 623., 624.,
      623., 624., 625., 626., 625., 626., 627., 628., 629., 630., 631., 632.,
      633., 634., 635., 636., 635., 636., 637., 638., 637., 638., 639., 640.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID3x8x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,  73.,  74.,  75.,  76.,
      93.,  94.,  95.,  96.,  97.,  98.,  99.,  100., 101., 102., 103., 104.,
      121., 122., 123., 124., 125., 126., 127., 128., 129., 130., 131., 132.,
      149., 150., 151., 152., 153., 154., 155., 156., 157., 158., 159., 160.,
      289., 290., 291., 292., 293., 294., 295., 296., 297., 298., 299., 300.,
      317., 318., 319., 320., 321., 322., 323., 324., 325., 326., 327., 328.,
      345., 346., 347., 348., 349., 350., 351., 352., 353., 354., 355., 356.,
      373., 374., 375., 376., 377., 378., 379., 380., 381., 382., 383., 384.,
      513., 514., 515., 516., 517., 518., 519., 520., 521., 522., 523., 524.,
      541., 542., 543., 544., 545., 546., 547., 548., 549., 550., 551., 552.,
      569., 570., 571., 572., 573., 574., 575., 576., 577., 578., 579., 580.,
      597., 598., 599., 600., 601., 602., 603., 604., 605., 606., 607., 608.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME3x8x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10.,   10.5,  11.,   12.,   13.,   14.,   14.5,  15.,   14.,   14.5,
      15.,   16.,   17.,   18.,   18.5,  19.,   18.,   18.5,  19.,   20.,
      21.,   22.,   22.5,  23.,   26.,   26.5,  27.,   28.,   29.,   30.,
      30.5,  31.,   34.,   34.5,  35.,   36.,   37.,   38.,   38.5,  39.,
      42.,   42.5,  43.,   44.,   45.,   46.,   46.5,  47.,   46.,   46.5,
      47.,   48.,   49.,   50.,   50.5,  51.,   50.,   50.5,  51.,   52.,
      53.,   54.,   54.5,  55.,   74.,   74.5,  75.,   76.,   77.,   78.,
      78.5,  79.,   78.,   78.5,  79.,   80.,   81.,   82.,   82.5,  83.,
      82.,   82.5,  83.,   84.,   85.,   86.,   86.5,  87.,   90.,   90.5,
      91.,   92.,   93.,   94.,   94.5,  95.,   98.,   98.5,  99.,   100.,
      101.,  102.,  102.5, 103.,  106.,  106.5, 107.,  108.,  109.,  110.,
      110.5, 111.,  110.,  110.5, 111.,  112.,  113.,  114.,  114.5, 115.,
      114.,  114.5, 115.,  116.,  117.,  118.,  118.5, 119.,  138.,  138.5,
      139.,  140.,  141.,  142.,  142.5, 143.,  142.,  142.5, 143.,  144.,
      145.,  146.,  146.5, 147.,  146.,  146.5, 147.,  148.,  149.,  150.,
      150.5, 151.,  154.,  154.5, 155.,  156.,  157.,  158.,  158.5, 159.,
      162.,  162.5, 163.,  164.,  165.,  166.,  166.5, 167.,  170.,  170.5,
      171.,  172.,  173.,  174.,  174.5, 175.,  174.,  174.5, 175.,  176.,
      177.,  178.,  178.5, 179.,  178.,  178.5, 179.,  180.,  181.,  182.,
      182.5, 183.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID3x8x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19.,  20.,  21.,  22.,  27.,  28.,  29.,  30.,  35.,  36.,  37.,  38.,
      43.,  44.,  45.,  46.,  83.,  84.,  85.,  86.,  91.,  92.,  93.,  94.,
      99.,  100., 101., 102., 107., 108., 109., 110., 147., 148., 149., 150.,
      155., 156., 157., 158., 163., 164., 165., 166., 171., 172., 173., 174.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME3x8x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19.,  20.,  20.,  21.,  21.,  22.,  23.,  24.,  25.,  26.,  27.,  28.,
      28.,  29.,  29.,  30.,  27.,  28.,  28.,  29.,  29.,  30.,  31.,  32.,
      33.,  34.,  35.,  36.,  36.,  37.,  37.,  38.,  35.,  36.,  36.,  37.,
      37.,  38.,  39.,  40.,  41.,  42.,  43.,  44.,  44.,  45.,  45.,  46.,
      51.,  52.,  52.,  53.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,
      60.,  61.,  61.,  62.,  67.,  68.,  68.,  69.,  69.,  70.,  71.,  72.,
      73.,  74.,  75.,  76.,  76.,  77.,  77.,  78.,  83.,  84.,  84.,  85.,
      85.,  86.,  87.,  88.,  89.,  90.,  91.,  92.,  92.,  93.,  93.,  94.,
      91.,  92.,  92.,  93.,  93.,  94.,  95.,  96.,  97.,  98.,  99.,  100.,
      100., 101., 101., 102., 99.,  100., 100., 101., 101., 102., 103., 104.,
      105., 106., 107., 108., 108., 109., 109., 110., 147., 148., 148., 149.,
      149., 150., 151., 152., 153., 154., 155., 156., 156., 157., 157., 158.,
      155., 156., 156., 157., 157., 158., 159., 160., 161., 162., 163., 164.,
      164., 165., 165., 166., 163., 164., 164., 165., 165., 166., 167., 168.,
      169., 170., 171., 172., 172., 173., 173., 174., 179., 180., 180., 181.,
      181., 182., 183., 184., 185., 186., 187., 188., 188., 189., 189., 190.,
      195., 196., 196., 197., 197., 198., 199., 200., 201., 202., 203., 204.,
      204., 205., 205., 206., 211., 212., 212., 213., 213., 214., 215., 216.,
      217., 218., 219., 220., 220., 221., 221., 222., 219., 220., 220., 221.,
      221., 222., 223., 224., 225., 226., 227., 228., 228., 229., 229., 230.,
      227., 228., 228., 229., 229., 230., 231., 232., 233., 234., 235., 236.,
      236., 237., 237., 238., 275., 276., 276., 277., 277., 278., 279., 280.,
      281., 282., 283., 284., 284., 285., 285., 286., 283., 284., 284., 285.,
      285., 286., 287., 288., 289., 290., 291., 292., 292., 293., 293., 294.,
      291., 292., 292., 293., 293., 294., 295., 296., 297., 298., 299., 300.,
      300., 301., 301., 302., 307., 308., 308., 309., 309., 310., 311., 312.,
      313., 314., 315., 316., 316., 317., 317., 318., 323., 324., 324., 325.,
      325., 326., 327., 328., 329., 330., 331., 332., 332., 333., 333., 334.,
      339., 340., 340., 341., 341., 342., 343., 344., 345., 346., 347., 348.,
      348., 349., 349., 350., 347., 348., 348., 349., 349., 350., 351., 352.,
      353., 354., 355., 356., 356., 357., 357., 358., 355., 356., 356., 357.,
      357., 358., 359., 360., 361., 362., 363., 364., 364., 365., 365., 366.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID3x8x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      37.,  38.,  39.,  40.,  41.,  42.,  43.,  44.,  53.,  54.,  55.,  56.,
      57.,  58.,  59.,  60.,  69.,  70.,  71.,  72.,  73.,  74.,  75.,  76.,
      85.,  86.,  87.,  88.,  89.,  90.,  91.,  92.,  165., 166., 167., 168.,
      169., 170., 171., 172., 181., 182., 183., 184., 185., 186., 187., 188.,
      197., 198., 199., 200., 201., 202., 203., 204., 213., 214., 215., 216.,
      217., 218., 219., 220., 293., 294., 295., 296., 297., 298., 299., 300.,
      309., 310., 311., 312., 313., 314., 315., 316., 325., 326., 327., 328.,
      329., 330., 331., 332., 341., 342., 343., 344., 345., 346., 347., 348.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, SAME3x8x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      37.,  38.,  39.,  40.,  39.,  40.,  41.,  42.,  41.,  42.,  43.,  44.,
      45.,  46.,  47.,  48.,  49.,  50.,  51.,  52.,  53.,  54.,  55.,  56.,
      55.,  56.,  57.,  58.,  57.,  58.,  59.,  60.,  53.,  54.,  55.,  56.,
      55.,  56.,  57.,  58.,  57.,  58.,  59.,  60.,  61.,  62.,  63.,  64.,
      65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,  71.,  72.,  73.,  74.,
      73.,  74.,  75.,  76.,  69.,  70.,  71.,  72.,  71.,  72.,  73.,  74.,
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,
      85.,  86.,  87.,  88.,  87.,  88.,  89.,  90.,  89.,  90.,  91.,  92.,
      101., 102., 103., 104., 103., 104., 105., 106., 105., 106., 107., 108.,
      109., 110., 111., 112., 113., 114., 115., 116., 117., 118., 119., 120.,
      119., 120., 121., 122., 121., 122., 123., 124., 133., 134., 135., 136.,
      135., 136., 137., 138., 137., 138., 139., 140., 141., 142., 143., 144.,
      145., 146., 147., 148., 149., 150., 151., 152., 151., 152., 153., 154.,
      153., 154., 155., 156., 165., 166., 167., 168., 167., 168., 169., 170.,
      169., 170., 171., 172., 173., 174., 175., 176., 177., 178., 179., 180.,
      181., 182., 183., 184., 183., 184., 185., 186., 185., 186., 187., 188.,
      181., 182., 183., 184., 183., 184., 185., 186., 185., 186., 187., 188.,
      189., 190., 191., 192., 193., 194., 195., 196., 197., 198., 199., 200.,
      199., 200., 201., 202., 201., 202., 203., 204., 197., 198., 199., 200.,
      199., 200., 201., 202., 201., 202., 203., 204., 205., 206., 207., 208.,
      209., 210., 211., 212., 213., 214., 215., 216., 215., 216., 217., 218.,
      217., 218., 219., 220., 293., 294., 295., 296., 295., 296., 297., 298.,
      297., 298., 299., 300., 301., 302., 303., 304., 305., 306., 307., 308.,
      309., 310., 311., 312., 311., 312., 313., 314., 313., 314., 315., 316.,
      309., 310., 311., 312., 311., 312., 313., 314., 313., 314., 315., 316.,
      317., 318., 319., 320., 321., 322., 323., 324., 325., 326., 327., 328.,
      327., 328., 329., 330., 329., 330., 331., 332., 325., 326., 327., 328.,
      327., 328., 329., 330., 329., 330., 331., 332., 333., 334., 335., 336.,
      337., 338., 339., 340., 341., 342., 343., 344., 343., 344., 345., 346.,
      345., 346., 347., 348., 357., 358., 359., 360., 359., 360., 361., 362.,
      361., 362., 363., 364., 365., 366., 367., 368., 369., 370., 371., 372.,
      373., 374., 375., 376., 375., 376., 377., 378., 377., 378., 379., 380.,
      389., 390., 391., 392., 391., 392., 393., 394., 393., 394., 395., 396.,
      397., 398., 399., 400., 401., 402., 403., 404., 405., 406., 407., 408.,
      407., 408., 409., 410., 409., 410., 411., 412., 421., 422., 423., 424.,
      423., 424., 425., 426., 425., 426., 427., 428., 429., 430., 431., 432.,
      433., 434., 435., 436., 437., 438., 439., 440., 439., 440., 441., 442.,
      441., 442., 443., 444., 437., 438., 439., 440., 439., 440., 441., 442.,
      441., 442., 443., 444., 445., 446., 447., 448., 449., 450., 451., 452.,
      453., 454., 455., 456., 455., 456., 457., 458., 457., 458., 459., 460.,
      453., 454., 455., 456., 455., 456., 457., 458., 457., 458., 459., 460.,
      461., 462., 463., 464., 465., 466., 467., 468., 469., 470., 471., 472.,
      471., 472., 473., 474., 473., 474., 475., 476., 549., 550., 551., 552.,
      551., 552., 553., 554., 553., 554., 555., 556., 557., 558., 559., 560.,
      561., 562., 563., 564., 565., 566., 567., 568., 567., 568., 569., 570.,
      569., 570., 571., 572., 565., 566., 567., 568., 567., 568., 569., 570.,
      569., 570., 571., 572., 573., 574., 575., 576., 577., 578., 579., 580.,
      581., 582., 583., 584., 583., 584., 585., 586., 585., 586., 587., 588.,
      581., 582., 583., 584., 583., 584., 585., 586., 585., 586., 587., 588.,
      589., 590., 591., 592., 593., 594., 595., 596., 597., 598., 599., 600.,
      599., 600., 601., 602., 601., 602., 603., 604., 613., 614., 615., 616.,
      615., 616., 617., 618., 617., 618., 619., 620., 621., 622., 623., 624.,
      625., 626., 627., 628., 629., 630., 631., 632., 631., 632., 633., 634.,
      633., 634., 635., 636., 645., 646., 647., 648., 647., 648., 649., 650.,
      649., 650., 651., 652., 653., 654., 655., 656., 657., 658., 659., 660.,
      661., 662., 663., 664., 663., 664., 665., 666., 665., 666., 667., 668.,
      677., 678., 679., 680., 679., 680., 681., 682., 681., 682., 683., 684.,
      685., 686., 687., 688., 689., 690., 691., 692., 693., 694., 695., 696.,
      695., 696., 697., 698., 697., 698., 699., 700., 693., 694., 695., 696.,
      695., 696., 697., 698., 697., 698., 699., 700., 701., 702., 703., 704.,
      705., 706., 707., 708., 709., 710., 711., 712., 711., 712., 713., 714.,
      713., 714., 715., 716., 709., 710., 711., 712., 711., 712., 713., 714.,
      713., 714., 715., 716., 717., 718., 719., 720., 721., 722., 723., 724.,
      725., 726., 727., 728., 727., 728., 729., 730., 729., 730., 731., 732.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(AvgWindow5Stride1Forward, VALID3x8x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,
      85.,  86.,  87.,  88.,  105., 106., 107., 108., 109., 110., 111., 112.,
      113., 114., 115., 116., 117., 118., 119., 120., 137., 138., 139., 140.,
      141., 142., 143., 144., 145., 146., 147., 148., 149., 150., 151., 152.,
      169., 170., 171., 172., 173., 174., 175., 176., 177., 178., 179., 180.,
      181., 182., 183., 184., 329., 330., 331., 332., 333., 334., 335., 336.,
      337., 338., 339., 340., 341., 342., 343., 344., 361., 362., 363., 364.,
      365., 366., 367., 368., 369., 370., 371., 372., 373., 374., 375., 376.,
      393., 394., 395., 396., 397., 398., 399., 400., 401., 402., 403., 404.,
      405., 406., 407., 408., 425., 426., 427., 428., 429., 430., 431., 432.,
      433., 434., 435., 436., 437., 438., 439., 440., 585., 586., 587., 588.,
      589., 590., 591., 592., 593., 594., 595., 596., 597., 598., 599., 600.,
      617., 618., 619., 620., 621., 622., 623., 624., 625., 626., 627., 628.,
      629., 630., 631., 632., 649., 650., 651., 652., 653., 654., 655., 656.,
      657., 658., 659., 660., 661., 662., 663., 664., 681., 682., 683., 684.,
      685., 686., 687., 688., 689., 690., 691., 692., 693., 694., 695., 696.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
